mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-04-30 11:50:28 +02:00
8a4ed2dd34
* libguile/discouraged.h: Remove. * libguile/deprecated.c (scm_internal_select, scm_thread_sleep) (scm_thread_usleep): Deprecate formerly discouraged names. * libguile/eq.h (SCM_EQ_P): * libguile/pairs.h (SCM_NULLP, SCM_NNULLP, SCM_CONSP, SCM_NCONSP): * libguile/boolean.h (SCM_FALSEP, SCM_NFALSEP, SCM_BOOLP, SCM_BOOL): (SCM_NEGATE_BOOL, SCM_BOOL_NOT): Undiscourage these names, because I'm not sure deprecating them will do any good. * libguile.h: * libguile/gen-scmconfig.c: * libguile/numbers.c: * libguile/init.c: * libguile/Makefile.am: * configure.ac: Remove bits that referenced discouraged.h, and dealt with the "discouraging" system.
744 lines
27 KiB
C
744 lines
27 KiB
C
/* This file contains definitions for deprecated features. When you
|
||
deprecate something, move it here when that is feasible.
|
||
*/
|
||
|
||
#ifndef SCM_DEPRECATED_H
|
||
#define SCM_DEPRECATED_H
|
||
|
||
/* Copyright (C) 2003,2004, 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
|
||
*
|
||
* This library is free software; you can redistribute it and/or
|
||
* modify it under the terms of the GNU Lesser General Public License
|
||
* as published by the Free Software Foundation; either version 3 of
|
||
* the License, or (at your option) any later version.
|
||
*
|
||
* This library is distributed in the hope that it will be useful, but
|
||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
* Lesser General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with this library; if not, write to the Free Software
|
||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
||
* 02110-1301 USA
|
||
*/
|
||
|
||
#include "libguile/__scm.h"
|
||
#include "libguile/strings.h"
|
||
#include "libguile/eval.h"
|
||
#include "libguile/throw.h"
|
||
#include "libguile/iselect.h"
|
||
|
||
#if (SCM_ENABLE_DEPRECATED == 1)
|
||
|
||
/* From eval.h: Macros for handling ilocs. These were deprecated in guile
|
||
* 1.7.0 on 2004-04-22. */
|
||
#define SCM_IFRINC (0x00000100L)
|
||
#define SCM_ICDR (0x00080000L)
|
||
#define SCM_IFRAME(n) ((long)((SCM_ICDR-SCM_IFRINC)>>8) \
|
||
& (SCM_UNPACK (n) >> 8))
|
||
#define SCM_IDIST(n) (SCM_UNPACK (n) >> 20)
|
||
#define SCM_ICDRP(n) (SCM_ICDR & SCM_UNPACK (n))
|
||
|
||
|
||
/* From tags.h: Macros to access internal symbol names of isyms. Deprecated
|
||
* in guile 1.7.0 on 2004-04-22. */
|
||
SCM_API char *scm_isymnames[];
|
||
#define SCM_ISYMNUM(n) 0
|
||
#define SCM_ISYMCHARS(n) "#@<deprecated>"
|
||
|
||
|
||
/* From tags.h: Macro checking for two tc16 types that are allocated to differ
|
||
* only in the 's'-bit. Deprecated in guile 1.7.0 on 2003-09-21. */
|
||
#define SCM_TYP16S(x) (0xfeff & SCM_CELL_TYPE (x))
|
||
|
||
|
||
/* From numbers.h: Macros checking for types, but avoiding a redundant check
|
||
* for !SCM_IMP. These were deprecated in guile 1.7.0 on 2003-09-06. */
|
||
#define SCM_SLOPPY_INEXACTP(x) (SCM_TYP16S (x) == scm_tc16_real)
|
||
#define SCM_SLOPPY_REALP(x) (SCM_TYP16 (x) == scm_tc16_real)
|
||
#define SCM_SLOPPY_COMPLEXP(x) (SCM_TYP16 (x) == scm_tc16_complex)
|
||
|
||
|
||
/* From structs.h:
|
||
Deprecated in Guile 1.9.5 on 2009-11-03. */
|
||
#define scm_vtable_index_vtable scm_vtable_index_self
|
||
#define scm_vtable_index_printer scm_vtable_index_instance_printer
|
||
#define scm_struct_i_free scm_vtable_index_instance_finalize
|
||
#define scm_struct_i_flags scm_vtable_index_flags
|
||
#define SCM_STRUCTF_MASK ((scm_t_bits)-1)
|
||
#define SCM_SET_VTABLE_DESTRUCTOR(X, D) (SCM_STRUCT_DATA(x)[scm_struct_i_free]=(scm_t_bits)(D))
|
||
|
||
#define scm_substring_move_left_x scm_substring_move_x
|
||
#define scm_substring_move_right_x scm_substring_move_x
|
||
|
||
#define scm_sizet size_t
|
||
|
||
SCM_DEPRECATED SCM scm_wta (SCM arg, const char *pos, const char *s_subr);
|
||
|
||
#define SCM_WNA 8
|
||
#define SCM_OUTOFRANGE 10
|
||
#define SCM_NALLOC 11
|
||
|
||
SCM_DEPRECATED void scm_register_module_xxx (char *module_name, void *init_func);
|
||
SCM_DEPRECATED SCM scm_registered_modules (void);
|
||
SCM_DEPRECATED SCM scm_clear_registered_modules (void);
|
||
|
||
SCM_DEPRECATED SCM scm_protect_object (SCM obj);
|
||
SCM_DEPRECATED SCM scm_unprotect_object (SCM obj);
|
||
|
||
#define SCM_SETAND_CAR(x, y) \
|
||
(SCM_SETCAR ((x), SCM_PACK (SCM_UNPACK (SCM_CAR (x)) & (y))))
|
||
#define SCM_SETOR_CAR(x, y)\
|
||
(SCM_SETCAR ((x), SCM_PACK (SCM_UNPACK (SCM_CAR (x)) | (y))))
|
||
#define SCM_SETAND_CDR(x, y)\
|
||
(SCM_SETCDR ((x), SCM_PACK (SCM_UNPACK (SCM_CDR (x)) & (y))))
|
||
#define SCM_SETOR_CDR(x, y)\
|
||
(SCM_SETCDR ((x), SCM_PACK (SCM_UNPACK (SCM_CDR (x)) | (y))))
|
||
#define SCM_FREEP(x) (0)
|
||
#define SCM_NFREEP(x) (1)
|
||
#define SCM_GCTYP16(x) SCM_TYP16 (x)
|
||
#define SCM_GCCDR(x) SCM_CDR (x)
|
||
SCM_DEPRECATED void scm_remember (SCM * ptr);
|
||
|
||
SCM_DEPRECATED SCM scm_make_module (SCM name);
|
||
SCM_DEPRECATED SCM scm_ensure_user_module (SCM name);
|
||
SCM_DEPRECATED SCM scm_load_scheme_module (SCM name);
|
||
|
||
#define scm_port scm_t_port
|
||
#define scm_ptob_descriptor scm_t_ptob_descriptor
|
||
#define scm_port_rw_active scm_t_port_rw_active
|
||
|
||
SCM_DEPRECATED SCM scm_close_all_ports_except (SCM ports);
|
||
|
||
#define scm_rstate scm_t_rstate
|
||
#define scm_rng scm_t_rng
|
||
|
||
#define SCM_SLOPPY_CONSP(x) ((1 & SCM_CELL_TYPE (x)) == 0)
|
||
#define SCM_SLOPPY_NCONSP(x) (!SCM_SLOPPY_CONSP(x))
|
||
|
||
#define scm_tc7_ssymbol scm_tc7_symbol
|
||
#define scm_tc7_msymbol scm_tc7_symbol
|
||
#define scm_tcs_symbols scm_tc7_symbol
|
||
|
||
SCM_DEPRECATED SCM scm_makstr (size_t len, int);
|
||
SCM_DEPRECATED SCM scm_makfromstr (const char *src, size_t len, int);
|
||
|
||
SCM_DEPRECATED SCM scm_variable_set_name_hint (SCM var, SCM hint);
|
||
SCM_DEPRECATED SCM scm_builtin_variable (SCM name);
|
||
|
||
SCM_DEPRECATED SCM scm_internal_with_fluids (SCM fluids, SCM vals,
|
||
SCM (*cproc)(void *),
|
||
void *cdata);
|
||
|
||
SCM_DEPRECATED SCM scm_make_gsubr (const char *name,
|
||
int req, int opt, int rst,
|
||
SCM (*fcn)());
|
||
SCM_DEPRECATED SCM scm_make_gsubr_with_generic (const char *name,
|
||
int req,
|
||
int opt,
|
||
int rst,
|
||
SCM (*fcn)(),
|
||
SCM *gf);
|
||
|
||
SCM_DEPRECATED SCM scm_create_hook (const char* name, int n_args);
|
||
|
||
#define SCM_LIST0 SCM_EOL
|
||
#define SCM_LIST1(e0) scm_cons ((e0), SCM_EOL)
|
||
#define SCM_LIST2(e0, e1) scm_cons2 ((e0), (e1), SCM_EOL)
|
||
#define SCM_LIST3(e0, e1, e2) scm_cons ((e0), SCM_LIST2 ((e1), (e2)))
|
||
#define SCM_LIST4(e0, e1, e2, e3)\
|
||
scm_cons2 ((e0), (e1), SCM_LIST2 ((e2), (e3)))
|
||
#define SCM_LIST5(e0, e1, e2, e3, e4)\
|
||
scm_cons ((e0), SCM_LIST4 ((e1), (e2), (e3), (e4)))
|
||
#define SCM_LIST6(e0, e1, e2, e3, e4, e5)\
|
||
scm_cons2 ((e0), (e1), SCM_LIST4 ((e2), (e3), (e4), (e5)))
|
||
#define SCM_LIST7(e0, e1, e2, e3, e4, e5, e6)\
|
||
scm_cons ((e0), SCM_LIST6 ((e1), (e2), (e3), (e4), (e5), (e6)))
|
||
#define SCM_LIST8(e0, e1, e2, e3, e4, e5, e6, e7)\
|
||
scm_cons2 ((e0), (e1), SCM_LIST6 ((e2), (e3), (e4), (e5), (e6), (e7)))
|
||
#define SCM_LIST9(e0, e1, e2, e3, e4, e5, e6, e7, e8)\
|
||
scm_cons ((e0),\
|
||
SCM_LIST8 ((e1), (e2), (e3), (e4), (e5), (e6), (e7), (e8)))
|
||
|
||
#define scm_listify scm_list_n
|
||
|
||
SCM_DEPRECATED SCM scm_sloppy_memq (SCM x, SCM lst);
|
||
SCM_DEPRECATED SCM scm_sloppy_memv (SCM x, SCM lst);
|
||
SCM_DEPRECATED SCM scm_sloppy_member (SCM x, SCM lst);
|
||
|
||
SCM_DEPRECATED SCM scm_read_and_eval_x (SCM port);
|
||
|
||
#define scm_subr_entry scm_t_subr_entry
|
||
|
||
#define SCM_SUBR_DOC(x) SCM_BOOL_F
|
||
|
||
SCM_DEPRECATED SCM scm_call_catching_errors (SCM (*thunk)(), SCM (*err_filter)(),
|
||
void * closure);
|
||
|
||
SCM_DEPRECATED long scm_make_smob_type_mfpe (char *name, size_t size,
|
||
SCM (*mark) (SCM),
|
||
size_t (*free) (SCM),
|
||
int (*print) (SCM, SCM,
|
||
scm_print_state*),
|
||
SCM (*equalp) (SCM, SCM));
|
||
|
||
SCM_DEPRECATED void scm_set_smob_mfpe (long tc,
|
||
SCM (*mark) (SCM),
|
||
size_t (*free) (SCM),
|
||
int (*print) (SCM, SCM, scm_print_state*),
|
||
SCM (*equalp) (SCM, SCM));
|
||
|
||
SCM_DEPRECATED size_t scm_smob_free (SCM obj);
|
||
|
||
SCM_DEPRECATED SCM scm_strprint_obj (SCM obj);
|
||
SCM_DEPRECATED SCM scm_read_0str (char *expr);
|
||
SCM_DEPRECATED SCM scm_eval_0str (const char *expr);
|
||
|
||
SCM_DEPRECATED char *scm_i_object_chars (SCM);
|
||
|
||
#define SCM_CHARS(x) scm_i_object_chars(x)
|
||
#define SCM_UCHARS(x) ((unsigned char *)SCM_CHARS(x))
|
||
|
||
SCM_DEPRECATED long scm_i_object_length (SCM);
|
||
|
||
#define SCM_LENGTH(x) scm_i_object_length(x)
|
||
|
||
#define scm_strhash(str, len, n) (scm_string_hash ((str), (len)) % (n))
|
||
|
||
SCM_DEPRECATED SCM scm_sym2ovcell_soft (SCM sym, SCM obarray);
|
||
SCM_DEPRECATED SCM scm_sym2ovcell (SCM sym, SCM obarray);
|
||
SCM_DEPRECATED SCM scm_intern_obarray_soft (const char *name, size_t len,
|
||
SCM obarray, unsigned int softness);
|
||
SCM_DEPRECATED SCM scm_intern_obarray (const char *name, size_t len, SCM obarray);
|
||
SCM_DEPRECATED SCM scm_symbol_value0 (const char *name);
|
||
|
||
SCM_DEPRECATED SCM scm_string_to_obarray_symbol (SCM o, SCM s, SCM softp);
|
||
SCM_DEPRECATED SCM scm_intern_symbol (SCM o, SCM s);
|
||
SCM_DEPRECATED SCM scm_unintern_symbol (SCM o, SCM s);
|
||
SCM_DEPRECATED SCM scm_symbol_binding (SCM o, SCM s);
|
||
#if 0
|
||
/* This name has been reused for real uninterned symbols. */
|
||
SCM_DEPRECATED SCM scm_symbol_interned_p (SCM o, SCM s);
|
||
#endif
|
||
SCM_DEPRECATED SCM scm_symbol_bound_p (SCM o, SCM s);
|
||
SCM_DEPRECATED SCM scm_symbol_set_x (SCM o, SCM s, SCM v);
|
||
|
||
SCM_DEPRECATED SCM scm_gentemp (SCM prefix, SCM obarray);
|
||
|
||
#define SCM_OPDIRP(x) (SCM_DIRP (x) && (SCM_DIR_OPEN_P (x)))
|
||
#define scm_fport scm_t_fport
|
||
#define scm_option scm_t_option
|
||
#define scm_srcprops scm_t_srcprops
|
||
#define scm_srcprops_chunk scm_t_srcprops_chunk
|
||
#define scm_array scm_t_array
|
||
#define scm_array_dim scm_t_array_dim
|
||
#define SCM_FUNC_NAME (scm_makfrom0str (FUNC_NAME))
|
||
|
||
#define SCM_WTA(pos, scm) \
|
||
do { scm_wta (scm, (char *) pos, FUNC_NAME); } while (0)
|
||
|
||
#define RETURN_SCM_WTA(pos, scm) \
|
||
do { return scm_wta (scm, (char *) pos, FUNC_NAME); } while (0)
|
||
|
||
#define SCM_VALIDATE_NUMBER_COPY(pos, z, cvar) \
|
||
do { \
|
||
if (SCM_I_INUMP (z)) \
|
||
cvar = (double) SCM_I_INUM (z); \
|
||
else if (SCM_REALP (z)) \
|
||
cvar = SCM_REAL_VALUE (z); \
|
||
else if (SCM_BIGP (z)) \
|
||
cvar = scm_i_big2dbl (z); \
|
||
else \
|
||
{ \
|
||
cvar = 0.0; \
|
||
SCM_WRONG_TYPE_ARG (pos, z); \
|
||
} \
|
||
} while (0)
|
||
|
||
#define SCM_VALIDATE_NUMBER_DEF_COPY(pos, number, def, cvar) \
|
||
do { \
|
||
if (SCM_UNBNDP (number)) \
|
||
cvar = def; \
|
||
else \
|
||
SCM_VALIDATE_NUMBER_COPY(pos, number, cvar); \
|
||
} while (0)
|
||
|
||
#define SCM_VALIDATE_OPDIR(pos, port) SCM_MAKE_VALIDATE (pos, port, OPDIRP)
|
||
|
||
/* Deprecated because we can not safely cast a SCM* to a scm_t_bits*
|
||
*/
|
||
|
||
#define SCM_CELL_WORD_LOC(x, n) ((scm_t_bits*)SCM_CELL_OBJECT_LOC((x),(n)))
|
||
|
||
/* Users shouldn't know about INUMs.
|
||
*/
|
||
|
||
SCM_DEPRECATED SCM scm_i_makinum (scm_t_signed_bits val);
|
||
SCM_DEPRECATED int scm_i_inump (SCM obj);
|
||
SCM_DEPRECATED scm_t_signed_bits scm_i_inum (SCM obj);
|
||
|
||
#define SCM_MAKINUM(x) scm_i_makinum(x)
|
||
#define SCM_INUM(x) scm_i_inum(x)
|
||
#define SCM_INUMP(x) scm_i_inump(x)
|
||
#define SCM_NINUMP(x) (!SCM_INUMP(x))
|
||
|
||
#define SCM_VALIDATE_INUM(pos, k) SCM_MAKE_VALIDATE_MSG (pos, k, INUMP, "exact integer")
|
||
|
||
#define SCM_VALIDATE_INUM_COPY(pos, k, cvar) \
|
||
do { \
|
||
SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \
|
||
cvar = SCM_I_INUM (k); \
|
||
} while (0)
|
||
|
||
#define SCM_VALIDATE_BIGINT(pos, k) SCM_MAKE_VALIDATE_MSG (pos, k, BIGP, "bignum")
|
||
|
||
#define SCM_VALIDATE_INUM_MIN(pos, k, min) \
|
||
do { \
|
||
SCM_ASSERT (SCM_I_INUMP(k), k, pos, FUNC_NAME); \
|
||
SCM_ASSERT_RANGE (pos, k, (SCM_I_INUM (k) >= min)); \
|
||
} while (0)
|
||
|
||
#define SCM_VALIDATE_INUM_MIN_COPY(pos, k, min, cvar) \
|
||
do { \
|
||
SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \
|
||
SCM_ASSERT_RANGE (pos, k, (SCM_I_INUM (k) >= min)); \
|
||
cvar = SCM_INUM (k); \
|
||
} while (0)
|
||
|
||
#define SCM_VALIDATE_INUM_MIN_DEF_COPY(pos, k, min, default, cvar) \
|
||
do { \
|
||
if (SCM_UNBNDP (k)) \
|
||
k = SCM_I_MAKINUM (default); \
|
||
SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \
|
||
SCM_ASSERT_RANGE (pos, k, (SCM_I_INUM (k) >= min)); \
|
||
cvar = SCM_INUM (k); \
|
||
} while (0)
|
||
|
||
#define SCM_VALIDATE_INUM_DEF(pos, k, default) \
|
||
do { \
|
||
if (SCM_UNBNDP (k)) \
|
||
k = SCM_I_MAKINUM (default); \
|
||
else SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \
|
||
} while (0)
|
||
|
||
#define SCM_VALIDATE_INUM_DEF_COPY(pos, k, default, cvar) \
|
||
do { \
|
||
if (SCM_UNBNDP (k)) \
|
||
{ \
|
||
k = SCM_I_MAKINUM (default); \
|
||
cvar = default; \
|
||
} \
|
||
else \
|
||
{ \
|
||
SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \
|
||
cvar = SCM_INUM (k); \
|
||
} \
|
||
} while (0)
|
||
|
||
/* [low, high) */
|
||
#define SCM_VALIDATE_INUM_RANGE(pos, k, low, high) \
|
||
do { SCM_ASSERT(SCM_I_INUMP(k), k, pos, FUNC_NAME); \
|
||
SCM_ASSERT_RANGE(pos, k, \
|
||
(SCM_I_INUM (k) >= low && \
|
||
SCM_I_INUM (k) < high)); \
|
||
} while (0)
|
||
|
||
#define SCM_VALIDATE_INUM_RANGE_COPY(pos, k, low, high, cvar) \
|
||
do { \
|
||
SCM_ASSERT (SCM_INUMP (k), k, pos, FUNC_NAME); \
|
||
SCM_ASSERT_RANGE (pos, k, low <= SCM_INUM (k) && SCM_INUM (k) < high); \
|
||
cvar = SCM_INUM (k); \
|
||
} while (0)
|
||
|
||
#define SCM_STRING_COERCE_0TERMINATION_X(x) (x)
|
||
|
||
/* XXX - buggy interface, STR might not be large enough.
|
||
|
||
Converts the given Scheme string OBJ into a C string, containing a copy
|
||
of OBJ's content with a trailing null byte. If LENP is non-NULL, set
|
||
*LENP to the string's length.
|
||
|
||
When STR is non-NULL it receives the copy and is returned by the function,
|
||
otherwise new memory is allocated and the caller is responsible for
|
||
freeing it via free(). If out of memory, NULL is returned.
|
||
|
||
Note that Scheme strings may contain arbitrary data, including null
|
||
characters. This means that null termination is not a reliable way to
|
||
determine the length of the returned value. However, the function always
|
||
copies the complete contents of OBJ, and sets *LENP to the length of the
|
||
scheme string (if LENP is non-null).
|
||
*/
|
||
SCM_DEPRECATED char *scm_c_string2str (SCM obj, char *str, size_t *lenp);
|
||
|
||
/* XXX - buggy interface, you don't know how many bytes have been copied.
|
||
|
||
Copy LEN characters at START from the Scheme string OBJ to memory
|
||
at STR. START is an index into OBJ; zero means the beginning of
|
||
the string. STR has already been allocated by the caller.
|
||
|
||
If START + LEN is off the end of OBJ, silently truncate the source
|
||
region to fit the string. If truncation occurs, the corresponding
|
||
area of STR is left unchanged.
|
||
*/
|
||
SCM_DEPRECATED char *scm_c_substring2str (SCM obj, char *str, size_t start, size_t len);
|
||
|
||
SCM_DEPRECATED char *scm_c_symbol2str (SCM obj, char *str, size_t *lenp);
|
||
|
||
/* Deprecated because the names belong to what is now
|
||
scm_truncate_number and scm_round_number.
|
||
*/
|
||
SCM_DEPRECATED double scm_truncate (double x);
|
||
SCM_DEPRECATED double scm_round (double x);
|
||
/* Deprecated, use scm_expt */
|
||
SCM_DEPRECATED SCM scm_sys_expt (SCM x, SCM y);
|
||
|
||
/* if your platform doesn't have asinh et al */
|
||
SCM_API double scm_asinh (double x);
|
||
SCM_API double scm_acosh (double x);
|
||
SCM_API double scm_atanh (double x);
|
||
SCM_API SCM scm_sys_atan2 (SCM z1, SCM z2);
|
||
|
||
/* Deprecated because we don't want people to access the internal
|
||
representation of strings directly.
|
||
*/
|
||
|
||
#define SCM_VALIDATE_STRING_COPY(pos, str, cvar) \
|
||
do { \
|
||
SCM_ASSERT (SCM_STRINGP (str), str, pos, FUNC_NAME); \
|
||
cvar = SCM_STRING_CHARS(str); \
|
||
} while (0)
|
||
|
||
/* validate a string and optional start/end arguments which default to
|
||
0/string-len. this is unrelated to the old shared substring
|
||
support, so please do not deprecate it :) */
|
||
#define SCM_VALIDATE_SUBSTRING_SPEC_COPY(pos_str, str, c_str, \
|
||
pos_start, start, c_start,\
|
||
pos_end, end, c_end) \
|
||
do {\
|
||
SCM_VALIDATE_STRING_COPY (pos_str, str, c_str);\
|
||
c_start = SCM_UNBNDP(start)? 0 : scm_to_size_t (start);\
|
||
c_end = SCM_UNBNDP(end)? SCM_STRING_LENGTH(str) : scm_to_size_t (end);\
|
||
SCM_ASSERT_RANGE (pos_start, start,\
|
||
0 <= c_start \
|
||
&& (size_t) c_start <= SCM_STRING_LENGTH (str));\
|
||
SCM_ASSERT_RANGE (pos_end, end,\
|
||
c_start <= c_end \
|
||
&& (size_t) c_end <= SCM_STRING_LENGTH (str));\
|
||
} while (0)
|
||
|
||
/* Deprecated because we don't want people to access the internals of
|
||
symbols directly.
|
||
*/
|
||
|
||
SCM_DEPRECATED char *scm_i_deprecated_symbol_chars (SCM sym);
|
||
SCM_DEPRECATED size_t scm_i_deprecated_symbol_length (SCM sym);
|
||
|
||
#define SCM_SYMBOL_CHARS(x) scm_i_deprecated_symbol_chars(x)
|
||
#define SCM_SYMBOL_LENGTH(x) scm_i_deprecated_symbol_length(x)
|
||
|
||
/* Deprecated because the macros used to evaluate the arguments more
|
||
than once and because the symbol of a keyword now has no dash.
|
||
*/
|
||
|
||
SCM_DEPRECATED int scm_i_keywordp (SCM obj);
|
||
SCM_DEPRECATED SCM scm_i_keywordsym (SCM keyword);
|
||
|
||
#define SCM_KEYWORDP(x) scm_i_keywordp(x)
|
||
#define SCM_KEYWORDSYM(x) scm_i_keywordsym(x)
|
||
|
||
/* Deprecated because we don't want to hand out unprotected pointers
|
||
to arrays, vectors, etc. */
|
||
|
||
#define SCM_VECTOR_MAX_LENGTH ((1L << 24) - 1)
|
||
|
||
SCM_DEPRECATED int scm_i_vectorp (SCM x);
|
||
SCM_DEPRECATED unsigned long scm_i_vector_length (SCM x);
|
||
SCM_DEPRECATED const SCM *scm_i_velts (SCM x);
|
||
SCM_DEPRECATED SCM *scm_i_writable_velts (SCM x);
|
||
SCM_DEPRECATED SCM scm_i_vector_ref (SCM x, size_t idx);
|
||
SCM_DEPRECATED void scm_i_vector_set (SCM x, size_t idx, SCM val);
|
||
SCM_DEPRECATED SCM scm_vector_equal_p (SCM x, SCM y);
|
||
|
||
#define SCM_VECTORP(x) scm_i_vectorp(x)
|
||
#define SCM_VECTOR_LENGTH(x) scm_i_vector_length(x)
|
||
#define SCM_VELTS(x) scm_i_velts(x)
|
||
#define SCM_WRITABLE_VELTS(x) scm_i_writable_velts(x)
|
||
#define SCM_VECTOR_REF(x,y) scm_i_vector_ref(x,y)
|
||
#define SCM_VECTOR_SET(x,y,z) scm_i_vector_set(x,y,z)
|
||
|
||
typedef scm_i_t_array scm_t_array;
|
||
|
||
SCM_DEPRECATED int scm_i_arrayp (SCM a);
|
||
SCM_DEPRECATED size_t scm_i_array_ndim (SCM a);
|
||
SCM_DEPRECATED int scm_i_array_contp (SCM a);
|
||
SCM_DEPRECATED scm_t_array *scm_i_array_mem (SCM a);
|
||
SCM_DEPRECATED SCM scm_i_array_v (SCM a);
|
||
SCM_DEPRECATED size_t scm_i_array_base (SCM a);
|
||
SCM_DEPRECATED scm_t_array_dim *scm_i_array_dims (SCM a);
|
||
|
||
#define SCM_ARRAYP(a) scm_i_arrayp(a)
|
||
#define SCM_ARRAY_NDIM(a) scm_i_array_ndim(a)
|
||
#define SCM_ARRAY_CONTP(a) scm_i_array_contp(a)
|
||
#define SCM_ARRAY_MEM(a) scm_i_array_mem(a)
|
||
#define SCM_ARRAY_V(a) scm_i_array_v(a)
|
||
#define SCM_ARRAY_BASE(a) scm_i_array_base(a)
|
||
#define SCM_ARRAY_DIMS(a) scm_i_array_dims(a)
|
||
|
||
SCM_DEPRECATED SCM scm_uniform_vector_read_x (SCM v, SCM port_or_fd,
|
||
SCM start, SCM end);
|
||
SCM_DEPRECATED SCM scm_uniform_vector_write (SCM v, SCM port_or_fd,
|
||
SCM start, SCM end);
|
||
SCM_DEPRECATED SCM scm_uniform_array_read_x (SCM ra, SCM port_or_fd,
|
||
SCM start, SCM end);
|
||
SCM_DEPRECATED SCM scm_uniform_array_write (SCM v, SCM port_or_fd,
|
||
SCM start, SCM end);
|
||
|
||
/* Deprecated because they should not be lvalues and we want people to
|
||
use the official interfaces.
|
||
*/
|
||
|
||
#define scm_cur_inp scm_i_cur_inp ()
|
||
#define scm_cur_outp scm_i_cur_outp ()
|
||
#define scm_cur_errp scm_i_cur_errp ()
|
||
#define scm_cur_loadp scm_i_cur_loadp ()
|
||
#define scm_progargs scm_i_progargs ()
|
||
#define scm_dynwinds scm_i_deprecated_dynwinds ()
|
||
#define scm_stack_base scm_i_stack_base ()
|
||
|
||
SCM_DEPRECATED SCM scm_i_cur_inp (void);
|
||
SCM_DEPRECATED SCM scm_i_cur_outp (void);
|
||
SCM_DEPRECATED SCM scm_i_cur_errp (void);
|
||
SCM_DEPRECATED SCM scm_i_cur_loadp (void);
|
||
SCM_DEPRECATED SCM scm_i_progargs (void);
|
||
SCM_DEPRECATED SCM scm_i_deprecated_dynwinds (void);
|
||
SCM_DEPRECATED SCM_STACKITEM *scm_i_stack_base (void);
|
||
|
||
/* Deprecated because it evaluates its argument twice.
|
||
*/
|
||
#define SCM_FLUIDP(x) scm_i_fluidp (x)
|
||
SCM_DEPRECATED int scm_i_fluidp (SCM x);
|
||
|
||
/* Deprecated in Guile 1.9.5 on 2009-11-15 because these are IPv4-only
|
||
functions which are deprecated upstream. */
|
||
|
||
SCM_DEPRECATED SCM scm_inet_aton (SCM address);
|
||
SCM_DEPRECATED SCM scm_inet_ntoa (SCM inetid);
|
||
|
||
/* In the old days, SCM_CRITICAL_SECTION_START stopped signal handlers
|
||
from running, since in those days the handler directly ran scheme
|
||
code, and that had to be avoided when the heap was not in a
|
||
consistent state etc. And since the scheme code could do a stack
|
||
swapping new continuation etc, signals had to be deferred around
|
||
various C library functions which were not safe or not known to be
|
||
safe to swap away, which was a lot of stuff.
|
||
|
||
These days signals are implemented with asyncs and don't directly
|
||
run scheme code in the handler, but hold it until an SCM_TICK etc
|
||
where it will be safe. This means interrupt protection is not
|
||
needed and SCM_CRITICAL_SECTION_START / SCM_CRITICAL_SECTION_END is
|
||
something of an anachronism.
|
||
|
||
What past SCM_CRITICAL_SECTION_START usage also did though was
|
||
indicate code that was not reentrant, ie. could not be reentered by
|
||
signal handler code. The present definitions are a mutex lock,
|
||
affording that reentrancy protection against the new guile 1.8
|
||
free-running posix threads.
|
||
|
||
One big problem with the present defintions though is that code which
|
||
throws an error from within a DEFER/ALLOW region will leave the
|
||
defer_mutex locked and hence hang other threads that attempt to enter a
|
||
similar DEFER/ALLOW region.
|
||
*/
|
||
|
||
SCM_DEPRECATED void scm_i_defer_ints_etc (void);
|
||
#define SCM_DEFER_INTS scm_i_defer_ints_etc ()
|
||
#define SCM_ALLOW_INTS scm_i_defer_ints_etc ()
|
||
#define SCM_REDEFER_INTS scm_i_defer_ints_etc ()
|
||
#define SCM_REALLOW_INTS scm_i_defer_ints_etc ()
|
||
|
||
/* In the old days (pre-1.8), this macro was sometimes used as an lvalue as
|
||
in "scm_mask_ints = 1" to block async execution. It no longer works. */
|
||
#define scm_mask_ints (scm_i_mask_ints ())
|
||
|
||
SCM_DEPRECATED int scm_i_mask_ints (void);
|
||
|
||
/* Deprecated since they are unnecessary and had not been documented.
|
||
*/
|
||
SCM_DEPRECATED SCM scm_guard (SCM guardian, SCM obj, int throw_p);
|
||
SCM_DEPRECATED SCM scm_get_one_zombie (SCM guardian);
|
||
|
||
/* Deprecated since guardians no longer have these special features.
|
||
*/
|
||
SCM_DEPRECATED SCM scm_destroy_guardian_x (SCM guardian);
|
||
SCM_DEPRECATED SCM scm_guardian_greedy_p (SCM guardian);
|
||
SCM_DEPRECATED SCM scm_guardian_destroyed_p (SCM guardian);
|
||
|
||
|
||
/* GC-related things deprecated with the move to BDW-GC starting from 1.9.3
|
||
(2009-09-15). */
|
||
|
||
SCM_DEPRECATED unsigned long scm_mallocated;
|
||
SCM_DEPRECATED unsigned long scm_mtrigger;
|
||
|
||
SCM_DEPRECATED size_t scm_max_segment_size;
|
||
|
||
#if defined (GUILE_DEBUG) || defined (GUILE_DEBUG_FREELIST)
|
||
SCM_DEPRECATED SCM scm_map_free_list (void);
|
||
#endif
|
||
|
||
#if defined (GUILE_DEBUG_FREELIST)
|
||
SCM_DEPRECATED SCM scm_gc_set_debug_check_freelist_x (SCM flag);
|
||
#endif
|
||
|
||
|
||
|
||
/* Deprecated 2009-11-27, scm_call_N is sufficient */
|
||
SCM_DEPRECATED scm_t_trampoline_0 scm_trampoline_0 (SCM proc);
|
||
SCM_DEPRECATED scm_t_trampoline_1 scm_trampoline_1 (SCM proc);
|
||
SCM_DEPRECATED scm_t_trampoline_2 scm_trampoline_2 (SCM proc);
|
||
|
||
|
||
|
||
/* Deprecated 2009-12-06, use the procedures instead */
|
||
#define SCM_PROCEDURE_WITH_SETTER_P(obj) (scm_is_true (scm_procedure_with_setter_p (obj)))
|
||
#define SCM_PROCEDURE(obj) SCM_STRUCT_PROCEDURE (obj, 0)
|
||
#define SCM_SETTER(obj) SCM_STRUCT_SETTER (obj, 1)
|
||
|
||
|
||
|
||
/* Deprecated 2010-01-05, use SCM_PRIMITIVE_P instead */
|
||
SCM_DEPRECATED int scm_i_subr_p (SCM x);
|
||
#define scm_subr_p(x) (scm_i_subr_p (x))
|
||
|
||
|
||
|
||
/* Deprecated 2010-01-31, use with-throw-handler instead */
|
||
SCM_DEPRECATED SCM scm_lazy_catch (SCM tag, SCM thunk, SCM handler);
|
||
SCM_DEPRECATED SCM scm_internal_lazy_catch (SCM tag,
|
||
scm_t_catch_body body,
|
||
void *body_data,
|
||
scm_t_catch_handler handler,
|
||
void *handler_data);
|
||
|
||
|
||
|
||
/* Deprecated 2010-03-31, use array-equal? instead */
|
||
SCM_DEPRECATED SCM scm_raequal (SCM ra0, SCM ra1);
|
||
|
||
/* Deprecated 2010-04-01, use the dynamic FFI instead */
|
||
SCM_DEPRECATED SCM scm_dynamic_args_call (SCM symb, SCM dobj, SCM args);
|
||
|
||
/* Deprecated 2010-05-12, no replacement */
|
||
SCM_DEPRECATED int scm_badargsp (SCM formals, SCM args);
|
||
|
||
/* Deprecated 2010-06-19, use call-with-error-handling instead */
|
||
SCM_DEPRECATED SCM scm_internal_stack_catch (SCM tag,
|
||
scm_t_catch_body body,
|
||
void *body_data,
|
||
scm_t_catch_handler handler,
|
||
void *handler_data);
|
||
|
||
|
||
|
||
/* These functions were "discouraged" in 1.8, and now are deprecated. */
|
||
|
||
/* scm_to_int, scm_from_int are the official functions to do the job,
|
||
but there is nothing wrong with using scm_num2int, etc.
|
||
|
||
These could be trivially defined via macros, but we leave them as
|
||
functions since existing code may take their addresses.
|
||
*/
|
||
|
||
SCM_DEPRECATED SCM scm_short2num (short n);
|
||
SCM_DEPRECATED SCM scm_ushort2num (unsigned short n);
|
||
SCM_DEPRECATED SCM scm_int2num (int n);
|
||
SCM_DEPRECATED SCM scm_uint2num (unsigned int n);
|
||
SCM_DEPRECATED SCM scm_long2num (long n);
|
||
SCM_DEPRECATED SCM scm_ulong2num (unsigned long n);
|
||
SCM_DEPRECATED SCM scm_size2num (size_t n);
|
||
SCM_DEPRECATED SCM scm_ptrdiff2num (scm_t_ptrdiff n);
|
||
SCM_DEPRECATED short scm_num2short (SCM num, unsigned long int pos,
|
||
const char *s_caller);
|
||
SCM_DEPRECATED unsigned short scm_num2ushort (SCM num, unsigned long int pos,
|
||
const char *s_caller);
|
||
SCM_DEPRECATED int scm_num2int (SCM num, unsigned long int pos,
|
||
const char *s_caller);
|
||
SCM_DEPRECATED unsigned int scm_num2uint (SCM num, unsigned long int pos,
|
||
const char *s_caller);
|
||
SCM_DEPRECATED long scm_num2long (SCM num, unsigned long int pos,
|
||
const char *s_caller);
|
||
SCM_DEPRECATED unsigned long scm_num2ulong (SCM num, unsigned long int pos,
|
||
const char *s_caller);
|
||
SCM_DEPRECATED scm_t_ptrdiff scm_num2ptrdiff (SCM num, unsigned long int pos,
|
||
const char *s_caller);
|
||
SCM_DEPRECATED size_t scm_num2size (SCM num, unsigned long int pos,
|
||
const char *s_caller);
|
||
#if SCM_SIZEOF_LONG_LONG != 0
|
||
SCM_DEPRECATED SCM scm_long_long2num (long long sl);
|
||
SCM_DEPRECATED SCM scm_ulong_long2num (unsigned long long sl);
|
||
SCM_DEPRECATED long long scm_num2long_long (SCM num, unsigned long int pos,
|
||
const char *s_caller);
|
||
SCM_DEPRECATED unsigned long long scm_num2ulong_long (SCM num, unsigned long int pos,
|
||
const char *s_caller);
|
||
#endif
|
||
|
||
SCM_DEPRECATED SCM scm_make_real (double x);
|
||
SCM_DEPRECATED double scm_num2dbl (SCM a, const char * why);
|
||
SCM_DEPRECATED SCM scm_float2num (float n);
|
||
SCM_DEPRECATED SCM scm_double2num (double n);
|
||
|
||
/* The next two are implemented in numbers.c since they use features
|
||
only available there.
|
||
*/
|
||
SCM_DEPRECATED float scm_num2float (SCM num, unsigned long int pos,
|
||
const char *s_caller);
|
||
SCM_DEPRECATED double scm_num2double (SCM num, unsigned long int pos,
|
||
const char *s_caller);
|
||
|
||
SCM_DEPRECATED SCM scm_make_complex (double x, double y);
|
||
|
||
/* Discouraged because they don't make the encoding explicit.
|
||
*/
|
||
|
||
SCM_DEPRECATED SCM scm_mem2symbol (const char *mem, size_t len);
|
||
SCM_DEPRECATED SCM scm_mem2uninterned_symbol (const char *mem, size_t len);
|
||
SCM_DEPRECATED SCM scm_str2symbol (const char *str);
|
||
|
||
SCM_DEPRECATED SCM scm_take_str (char *s, size_t len);
|
||
SCM_DEPRECATED SCM scm_take0str (char *s);
|
||
SCM_DEPRECATED SCM scm_mem2string (const char *src, size_t len);
|
||
SCM_DEPRECATED SCM scm_str2string (const char *src);
|
||
SCM_DEPRECATED SCM scm_makfrom0str (const char *src);
|
||
SCM_DEPRECATED SCM scm_makfrom0str_opt (const char *src);
|
||
|
||
/* Discouraged because scm_c_make_string has a better name and is more
|
||
consistent with make-string.
|
||
*/
|
||
SCM_DEPRECATED SCM scm_allocate_string (size_t len);
|
||
|
||
/* Discouraged because they are just strange.
|
||
*/
|
||
|
||
SCM_DEPRECATED SCM scm_make_keyword_from_dash_symbol (SCM symbol);
|
||
SCM_DEPRECATED SCM scm_keyword_dash_symbol (SCM keyword);
|
||
|
||
/* Discouraged because it does not state what encoding S is in.
|
||
*/
|
||
|
||
SCM_DEPRECATED SCM scm_c_make_keyword (const char *s);
|
||
|
||
SCM_DEPRECATED unsigned int scm_thread_sleep (unsigned int);
|
||
SCM_DEPRECATED unsigned long scm_thread_usleep (unsigned long);
|
||
SCM_DEPRECATED int scm_internal_select (int fds,
|
||
SELECT_TYPE *rfds,
|
||
SELECT_TYPE *wfds,
|
||
SELECT_TYPE *efds,
|
||
struct timeval *timeout);
|
||
|
||
|
||
void scm_i_init_deprecated (void);
|
||
|
||
#endif
|
||
|
||
#endif /* SCM_DEPRECATED_H */
|