[bpt/guile.git] / libguile / deprecated.h

/* 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 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 2.1 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include "libguile/__scm.h"
#include "libguile/strings.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 eval.h: Macros for handling ilocs.  These were deprecated in guile
 * 1.7.0 on 2003-06-04.  */
#define SCM_ILOC00		SCM_MAKE_ITAG8(0L, scm_tc8_iloc)
#define SCM_IDINC		(0x00100000L)
#define SCM_IDSTMSK		(-SCM_IDINC)


/* From eval.h: Error messages of the evaluator.  These were deprecated in
 * guile 1.7.0 on 2003-06-02.  */
SCM_API const char scm_s_expression[];
SCM_API const char scm_s_test[];
SCM_API const char scm_s_body[];
SCM_API const char scm_s_bindings[];
SCM_API const char scm_s_variable[];
SCM_API const char scm_s_clauses[];
SCM_API const char scm_s_formals[];


/* From eval.h: Helper macros for evaluation and application.  These were
 * deprecated in guile 1.7.0 on 2003-06-02.  */
#define SCM_EVALIM2(x) \
  ((scm_is_eq ((x), SCM_EOL) \
    ? scm_misc_error (NULL, scm_s_expression, SCM_EOL), 0 \
    : 0), \
   (x))
#define SCM_EVALIM(x, env) (SCM_ILOCP (x) \
                            ? *scm_ilookup ((x), env) \
			    : SCM_EVALIM2(x))
#define SCM_XEVAL(x, env) (scm_i_eval_x ((x), (env)))
#define SCM_XEVALCAR(x, env) (SCM_SYMBOLP (SCM_CAR (x)) \
			      ? *scm_lookupcar (x, env, 1) \
			      : scm_i_eval_x (SCM_CAR (x), (env)))


#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_API 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_API void scm_register_module_xxx (char *module_name, void *init_func);
SCM_API SCM scm_registered_modules (void);
SCM_API SCM scm_clear_registered_modules (void);

SCM_API SCM scm_protect_object (SCM obj);
SCM_API 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) (SCM_FREE_CELL_P (x))
#define SCM_NFREEP(x) (!SCM_FREE_CELL_P (x))
#define SCM_GC8MARKP(x) SCM_GC_MARK_P (x)
#define SCM_SETGC8MARK(x) SCM_SET_GC_MARK (x)
#define SCM_CLRGC8MARK(x) SCM_CLEAR_GC_MARK (x)
#define SCM_GCTYP16(x) SCM_TYP16 (x)
#define SCM_GCCDR(x) SCM_CDR (x)
SCM_API void scm_remember (SCM * ptr);

SCM_API SCM scm_the_root_module (void);
SCM_API SCM scm_make_module (SCM name);
SCM_API SCM scm_ensure_user_module (SCM name);
SCM_API 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_API 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_API SCM scm_makstr (size_t len, int);
SCM_API SCM scm_makfromstr (const char *src, size_t len, int);

SCM_API SCM scm_variable_set_name_hint (SCM var, SCM hint);
SCM_API SCM scm_builtin_variable (SCM name);

SCM_API SCM scm_internal_with_fluids (SCM fluids, SCM vals,
				      SCM (*cproc)(void *), void *cdata);

SCM_API SCM scm_make_gsubr (const char *name, int req, int opt, int rst,
			    SCM (*fcn)());
SCM_API SCM scm_make_gsubr_with_generic (const char *name,
					 int req,
					 int opt,
					 int rst,
					 SCM (*fcn)(),
					 SCM *gf);

extern 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_API SCM scm_sloppy_memq (SCM x, SCM lst);
SCM_API SCM scm_sloppy_memv (SCM x, SCM lst);
SCM_API SCM scm_sloppy_member (SCM x, SCM lst);

SCM_API 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_API SCM scm_make_subr (const char *name, int type, SCM (*fcn) ());
SCM_API SCM scm_make_subr_with_generic (const char *name,
					int type,
					SCM (*fcn) (),
					SCM *gf);
SCM_API SCM scm_make_subr_opt (const char *name, 
			       int type, 
			       SCM (*fcn) (),
			       int set);

SCM_API SCM scm_call_catching_errors (SCM (*thunk)(), SCM (*err_filter)(),
				      void * closure);

SCM_API 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_API 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_API SCM scm_strprint_obj (SCM obj);
SCM_API SCM scm_read_0str (char *expr);
SCM_API SCM scm_eval_0str (const char *expr);

SCM_API 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_API 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_API SCM scm_sym2ovcell_soft (SCM sym, SCM obarray);
SCM_API SCM scm_sym2ovcell (SCM sym, SCM obarray);
SCM_API SCM scm_intern_obarray_soft (const char *name, size_t len,
				     SCM obarray, unsigned int softness);
SCM_API SCM scm_intern_obarray (const char *name, size_t len, SCM obarray);
SCM_API SCM scm_symbol_value0 (const char *name);

SCM_API SCM scm_string_to_obarray_symbol (SCM o, SCM s, SCM softp);
SCM_API SCM scm_intern_symbol (SCM o, SCM s);
SCM_API SCM scm_unintern_symbol (SCM o, SCM s);
SCM_API SCM scm_symbol_binding (SCM o, SCM s);
#if 0
/* This name has been reused for real uninterned symbols. */
SCM_API SCM scm_symbol_interned_p (SCM o, SCM s);
#endif
SCM_API SCM scm_symbol_bound_p (SCM o, SCM s);
SCM_API SCM scm_symbol_set_x (SCM o, SCM s, SCM v);

SCM_API 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_info_frame scm_t_info_frame
#define scm_stack scm_t_stack
#define scm_array scm_t_array
#define scm_array_dim scm_t_array_dim
#define SCM_ARRAY_CONTIGUOUS SCM_ARRAY_FLAG_CONTIGUOUS
#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_API SCM SCM_MAKINUM (scm_t_signed_bits val);
SCM_API int SCM_INUMP (SCM obj);
#define SCM_NINUMP(x) (!SCM_INUMP(x))
SCM_API scm_t_signed_bits SCM_INUM (SCM obj);

#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_API 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_API char *scm_c_substring2str (SCM obj, char *str, size_t start, size_t len);

SCM_API 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_API double scm_truncate (double x);
SCM_API double scm_round (double x);

/* 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_API char *SCM_SYMBOL_CHARS (SCM sym);
SCM_API size_t SCM_SYMBOL_LENGTH (SCM sym);

/* Deprecated because the macros used to evaluate the arguments more
   than once and because the symbol of a keyword now has no dash.
*/

SCM_API int SCM_KEYWORDP (SCM obj);
SCM_API SCM SCM_KEYWORDSYM (SCM keyword);

/* Deprecated because we don't want to hand out unprotected pointers
   to arrays, vectors, etc. */

#define SCM_VECTOR_MAX_LENGTH ((1L << 24) - 1)

SCM_API int SCM_VECTORP (SCM x);
SCM_API unsigned long SCM_VECTOR_LENGTH (SCM x);
SCM_API const SCM *SCM_VELTS (SCM x);
SCM_API SCM *SCM_WRITABLE_VELTS (SCM x);
SCM_API SCM SCM_VECTOR_REF (SCM x, size_t idx);
SCM_API void SCM_VECTOR_SET (SCM x, size_t idx, SCM val);
SCM_API SCM scm_vector_equal_p (SCM x, SCM y);

void scm_i_init_deprecated (void);

#endif

#endif /* SCM_DEPRECATED_H */
Commit	Line	Data
19e2247d MV	1	/* This file contains definitions for deprecated features. When you
	2	deprecate something, move it here when that is feasible.
	3	*/
	4
	5	#ifndef SCM_DEPRECATED_H
	6	#define SCM_DEPRECATED_H
	7
434f2f7a	8	/* Copyright (C) 2003,2004 Free Software Foundation, Inc.
19e2247d	9	*
73be1d9e MV	10	* This library is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU Lesser General Public
	12	* License as published by the Free Software Foundation; either
	13	* version 2.1 of the License, or (at your option) any later version.
19e2247d	14	*
73be1d9e	15	* This library is distributed in the hope that it will be useful,
19e2247d	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
73be1d9e MV	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
73be1d9e MV	18	* Lesser General Public License for more details.
19e2247d	19	*
73be1d9e MV	20	* You should have received a copy of the GNU Lesser General Public
	21	* License along with this library; if not, write to the Free Software
	22	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	23	*/
19e2247d MV	24
19e2247d MV	25	#include "libguile/__scm.h"
55d30fac	26	#include "libguile/strings.h"
19e2247d MV	27
	28	#if (SCM_ENABLE_DEPRECATED == 1)
	29
7e6e6b37 DH	30	/* From eval.h: Macros for handling ilocs. These were deprecated in guile
	31	* 1.7.0 on 2004-04-22. */
	32	#define SCM_IFRINC (0x00000100L)
	33	#define SCM_ICDR (0x00080000L)
	34	#define SCM_IFRAME(n) ((long)((SCM_ICDR-SCM_IFRINC)>>8) \
	35	& (SCM_UNPACK (n) >> 8))
	36	#define SCM_IDIST(n) (SCM_UNPACK (n) >> 20)
	37	#define SCM_ICDRP(n) (SCM_ICDR & SCM_UNPACK (n))
	38
	39
	40	/* From tags.h: Macros to access internal symbol names of isyms. Deprecated
	41	* in guile 1.7.0 on 2004-04-22. */
	42	SCM_API char *scm_isymnames[];
	43	#define SCM_ISYMNUM(n) 0
	44	#define SCM_ISYMCHARS(n) "#@<deprecated>"
	45
	46
f03314f9 DH	47	/* From tags.h: Macro checking for two tc16 types that are allocated to differ
	48	* only in the 's'-bit. Deprecated in guile 1.7.0 on 2003-09-21. */
	49	#define SCM_TYP16S(x) (0xfeff & SCM_CELL_TYPE (x))
	50
	51
0d5e3480 DH	52	/* From numbers.h: Macros checking for types, but avoiding a redundant check
	53	* for !SCM_IMP. These were deprecated in guile 1.7.0 on 2003-09-06. */
	54	#define SCM_SLOPPY_INEXACTP(x) (SCM_TYP16S (x) == scm_tc16_real)
	55	#define SCM_SLOPPY_REALP(x) (SCM_TYP16 (x) == scm_tc16_real)
	56	#define SCM_SLOPPY_COMPLEXP(x) (SCM_TYP16 (x) == scm_tc16_complex)
	57
	58
d0624e39 DH	59	/* From eval.h: Macros for handling ilocs. These were deprecated in guile
	60	* 1.7.0 on 2003-06-04. */
	61	#define SCM_ILOC00 SCM_MAKE_ITAG8(0L, scm_tc8_iloc)
	62	#define SCM_IDINC (0x00100000L)
	63	#define SCM_IDSTMSK (-SCM_IDINC)
	64
	65
e90c3a89 DH	66	/* From eval.h: Error messages of the evaluator. These were deprecated in
	67	* guile 1.7.0 on 2003-06-02. */
	68	SCM_API const char scm_s_expression[];
	69	SCM_API const char scm_s_test[];
	70	SCM_API const char scm_s_body[];
	71	SCM_API const char scm_s_bindings[];
	72	SCM_API const char scm_s_variable[];
	73	SCM_API const char scm_s_clauses[];
	74	SCM_API const char scm_s_formals[];
	75
	76
	77	/* From eval.h: Helper macros for evaluation and application. These were
	78	* deprecated in guile 1.7.0 on 2003-06-02. */
	79	#define SCM_EVALIM2(x) \
2ad58b2a	80	((scm_is_eq ((x), SCM_EOL) \
e90c3a89 DH	81	? scm_misc_error (NULL, scm_s_expression, SCM_EOL), 0 \
	82	: 0), \
	83	(x))
	84	#define SCM_EVALIM(x, env) (SCM_ILOCP (x) \
	85	? *scm_ilookup ((x), env) \
	86	: SCM_EVALIM2(x))
434f2f7a DH	87	#define SCM_XEVAL(x, env) (scm_i_eval_x ((x), (env)))
	88	#define SCM_XEVALCAR(x, env) (SCM_SYMBOLP (SCM_CAR (x)) \
	89	? *scm_lookupcar (x, env, 1) \
	90	: scm_i_eval_x (SCM_CAR (x), (env)))
e90c3a89 DH	91
e90c3a89 DH	92
19e2247d MV	93	#define scm_substring_move_left_x scm_substring_move_x
	94	#define scm_substring_move_right_x scm_substring_move_x
	95
55d30fac	96	#define scm_sizet size_t
19e2247d	97
55d30fac	98	SCM_API SCM scm_wta (SCM arg, const char pos, const char s_subr);
19e2247d	99
55d30fac MV	100	#define SCM_WNA 8
	101	#define SCM_OUTOFRANGE 10
	102	#define SCM_NALLOC 11
19e2247d	103
55d30fac MV	104	SCM_API void scm_register_module_xxx (char module_name, void init_func);
	105	SCM_API SCM scm_registered_modules (void);
	106	SCM_API SCM scm_clear_registered_modules (void);
19e2247d	107
a0454d72 MV	108	SCM_API SCM scm_protect_object (SCM obj);
	109	SCM_API SCM scm_unprotect_object (SCM obj);
	110
	111	#define SCM_SETAND_CAR(x, y) \
	112	(SCM_SETCAR ((x), SCM_PACK (SCM_UNPACK (SCM_CAR (x)) & (y))))
	113	#define SCM_SETOR_CAR(x, y)\
	114	(SCM_SETCAR ((x), SCM_PACK (SCM_UNPACK (SCM_CAR (x)) \| (y))))
	115	#define SCM_SETAND_CDR(x, y)\
	116	(SCM_SETCDR ((x), SCM_PACK (SCM_UNPACK (SCM_CDR (x)) & (y))))
	117	#define SCM_SETOR_CDR(x, y)\
	118	(SCM_SETCDR ((x), SCM_PACK (SCM_UNPACK (SCM_CDR (x)) \| (y))))
	119	#define SCM_FREEP(x) (SCM_FREE_CELL_P (x))
	120	#define SCM_NFREEP(x) (!SCM_FREE_CELL_P (x))
7aaf8dc9 MD	121	#define SCM_GC8MARKP(x) SCM_GC_MARK_P (x)
	122	#define SCM_SETGC8MARK(x) SCM_SET_GC_MARK (x)
	123	#define SCM_CLRGC8MARK(x) SCM_CLEAR_GC_MARK (x)
a0454d72 MV	124	#define SCM_GCTYP16(x) SCM_TYP16 (x)
	125	#define SCM_GCCDR(x) SCM_CDR (x)
	126	SCM_API void scm_remember (SCM * ptr);
	127
	128	SCM_API SCM scm_the_root_module (void);
	129	SCM_API SCM scm_make_module (SCM name);
	130	SCM_API SCM scm_ensure_user_module (SCM name);
	131	SCM_API SCM scm_load_scheme_module (SCM name);
	132
	133	#define scm_port scm_t_port
	134	#define scm_ptob_descriptor scm_t_ptob_descriptor
	135	#define scm_port_rw_active scm_t_port_rw_active
	136
	137	SCM_API SCM scm_close_all_ports_except (SCM ports);
	138
97f28fa4 MV	139	#define scm_rstate scm_t_rstate
	140	#define scm_rng scm_t_rng
	141
	142	#define SCM_SLOPPY_CONSP(x) ((1 & SCM_CELL_TYPE (x)) == 0)
	143	#define SCM_SLOPPY_NCONSP(x) (!SCM_SLOPPY_CONSP(x))
	144
	145	#define scm_tc7_ssymbol scm_tc7_symbol
	146	#define scm_tc7_msymbol scm_tc7_symbol
	147	#define scm_tcs_symbols scm_tc7_symbol
	148
965445d4 MV	149	SCM_API SCM scm_makstr (size_t len, int);
	150	SCM_API SCM scm_makfromstr (const char *src, size_t len, int);
	151
	152	SCM_API SCM scm_variable_set_name_hint (SCM var, SCM hint);
	153	SCM_API SCM scm_builtin_variable (SCM name);
	154
	155	SCM_API SCM scm_internal_with_fluids (SCM fluids, SCM vals,
	156	SCM (cproc)(void ), void *cdata);
	157
	158	SCM_API SCM scm_make_gsubr (const char *name, int req, int opt, int rst,
	159	SCM (*fcn)());
	160	SCM_API SCM scm_make_gsubr_with_generic (const char *name,
	161	int req,
	162	int opt,
	163	int rst,
	164	SCM (*fcn)(),
	165	SCM *gf);
	166
	167	extern SCM scm_create_hook (const char* name, int n_args);
	168
	169	#define SCM_LIST0 SCM_EOL
	170	#define SCM_LIST1(e0) scm_cons ((e0), SCM_EOL)
	171	#define SCM_LIST2(e0, e1) scm_cons2 ((e0), (e1), SCM_EOL)
	172	#define SCM_LIST3(e0, e1, e2) scm_cons ((e0), SCM_LIST2 ((e1), (e2)))
	173	#define SCM_LIST4(e0, e1, e2, e3)\
	174	scm_cons2 ((e0), (e1), SCM_LIST2 ((e2), (e3)))
	175	#define SCM_LIST5(e0, e1, e2, e3, e4)\
	176	scm_cons ((e0), SCM_LIST4 ((e1), (e2), (e3), (e4)))
	177	#define SCM_LIST6(e0, e1, e2, e3, e4, e5)\
	178	scm_cons2 ((e0), (e1), SCM_LIST4 ((e2), (e3), (e4), (e5)))
	179	#define SCM_LIST7(e0, e1, e2, e3, e4, e5, e6)\
	180	scm_cons ((e0), SCM_LIST6 ((e1), (e2), (e3), (e4), (e5), (e6)))
	181	#define SCM_LIST8(e0, e1, e2, e3, e4, e5, e6, e7)\
	182	scm_cons2 ((e0), (e1), SCM_LIST6 ((e2), (e3), (e4), (e5), (e6), (e7)))
	183	#define SCM_LIST9(e0, e1, e2, e3, e4, e5, e6, e7, e8)\
	184	scm_cons ((e0),\
	185	SCM_LIST8 ((e1), (e2), (e3), (e4), (e5), (e6), (e7), (e8)))
	186
	187	#define scm_listify scm_list_n
	188
	189	SCM_API SCM scm_sloppy_memq (SCM x, SCM lst);
	190	SCM_API SCM scm_sloppy_memv (SCM x, SCM lst);
	191	SCM_API SCM scm_sloppy_member (SCM x, SCM lst);
	192
	193	SCM_API SCM scm_read_and_eval_x (SCM port);
	194
4abecea8 MV	195	#define scm_subr_entry scm_t_subr_entry
	196
	197	#define SCM_SUBR_DOC(x) SCM_BOOL_F
	198
	199	SCM_API SCM scm_make_subr (const char name, int type, SCM (fcn) ());
	200	SCM_API SCM scm_make_subr_with_generic (const char *name,
	201	int type,
	202	SCM (*fcn) (),
	203	SCM *gf);
	204	SCM_API SCM scm_make_subr_opt (const char *name,
	205	int type,
	206	SCM (*fcn) (),
	207	int set);
	208
	209	SCM_API SCM scm_call_catching_errors (SCM (thunk)(), SCM (err_filter)(),
	210	void * closure);
	211
	212	SCM_API long scm_make_smob_type_mfpe (char *name, size_t size,
	213	SCM (*mark) (SCM),
	214	size_t (*free) (SCM),
	215	int (*print) (SCM, SCM,
	216	scm_print_state*),
	217	SCM (*equalp) (SCM, SCM));
	218
	219	SCM_API void scm_set_smob_mfpe (long tc,
	220	SCM (*mark) (SCM),
	221	size_t (*free) (SCM),
	222	int (print) (SCM, SCM, scm_print_state),
	223	SCM (*equalp) (SCM, SCM));
	224
	225	SCM_API SCM scm_strprint_obj (SCM obj);
	226	SCM_API SCM scm_read_0str (char *expr);
	227	SCM_API SCM scm_eval_0str (const char *expr);
	228
a725fa95 MV	229	SCM_API char *scm_i_object_chars (SCM);
	230
	231	#define SCM_CHARS(x) scm_i_object_chars(x)
	232	#define SCM_UCHARS(x) ((unsigned char *)SCM_CHARS(x))
	233
	234	SCM_API long scm_i_object_length (SCM);
	235
	236	#define SCM_LENGTH(x) scm_i_object_length(x)
	237
cc5c1b66 MV	238	#define scm_strhash(str, len, n) (scm_string_hash ((str), (len)) % (n))
	239
	240	SCM_API SCM scm_sym2ovcell_soft (SCM sym, SCM obarray);
	241	SCM_API SCM scm_sym2ovcell (SCM sym, SCM obarray);
	242	SCM_API SCM scm_intern_obarray_soft (const char *name, size_t len,
	243	SCM obarray, unsigned int softness);
	244	SCM_API SCM scm_intern_obarray (const char *name, size_t len, SCM obarray);
	245	SCM_API SCM scm_symbol_value0 (const char *name);
	246
	247	SCM_API SCM scm_string_to_obarray_symbol (SCM o, SCM s, SCM softp);
	248	SCM_API SCM scm_intern_symbol (SCM o, SCM s);
	249	SCM_API SCM scm_unintern_symbol (SCM o, SCM s);
	250	SCM_API SCM scm_symbol_binding (SCM o, SCM s);
	251	#if 0
	252	/* This name has been reused for real uninterned symbols. */
	253	SCM_API SCM scm_symbol_interned_p (SCM o, SCM s);
	254	#endif
	255	SCM_API SCM scm_symbol_bound_p (SCM o, SCM s);
	256	SCM_API SCM scm_symbol_set_x (SCM o, SCM s, SCM v);
	257
	258	SCM_API SCM scm_gentemp (SCM prefix, SCM obarray);
	259
8de7acbd MV	260	#define SCM_OPDIRP(x) (SCM_DIRP (x) && (SCM_DIR_OPEN_P (x)))
	261	#define scm_fport scm_t_fport
	262	#define scm_option scm_t_option
	263	#define scm_srcprops scm_t_srcprops
	264	#define scm_srcprops_chunk scm_t_srcprops_chunk
	265	#define scm_info_frame scm_t_info_frame
	266	#define scm_stack scm_t_stack
	267	#define scm_array scm_t_array
	268	#define scm_array_dim scm_t_array_dim
	269	#define SCM_ARRAY_CONTIGUOUS SCM_ARRAY_FLAG_CONTIGUOUS
	270	#define SCM_FUNC_NAME (scm_makfrom0str (FUNC_NAME))
	271
	272	#define SCM_WTA(pos, scm) \
	273	do { scm_wta (scm, (char *) pos, FUNC_NAME); } while (0)
	274
	275	#define RETURN_SCM_WTA(pos, scm) \
	276	do { return scm_wta (scm, (char *) pos, FUNC_NAME); } while (0)
	277
	278	#define SCM_VALIDATE_NUMBER_COPY(pos, z, cvar) \
	279	do { \
3aa13a05 MV	280	if (SCM_I_INUMP (z)) \
3aa13a05 MV	281	cvar = (double) SCM_I_INUM (z); \
8de7acbd MV	282	else if (SCM_REALP (z)) \
	283	cvar = SCM_REAL_VALUE (z); \
	284	else if (SCM_BIGP (z)) \
	285	cvar = scm_i_big2dbl (z); \
	286	else \
	287	{ \
	288	cvar = 0.0; \
	289	SCM_WRONG_TYPE_ARG (pos, z); \
	290	} \
	291	} while (0)
	292
	293	#define SCM_VALIDATE_NUMBER_DEF_COPY(pos, number, def, cvar) \
	294	do { \
	295	if (SCM_UNBNDP (number)) \
	296	cvar = def; \
	297	else \
	298	SCM_VALIDATE_NUMBER_COPY(pos, number, cvar); \
	299	} while (0)
	300
	301	#define SCM_VALIDATE_OPDIR(pos, port) SCM_MAKE_VALIDATE (pos, port, OPDIRP)
	302
41a2f6fc MV	303	/* Deprecated because we can not safely cast a SCM* to a scm_t_bits*
	304	*/
	305
	306	#define SCM_CELL_WORD_LOC(x, n) ((scm_t_bits*)SCM_CELL_OBJECT_LOC((x),(n)))
	307
8805b77d MV	308	/* Users shouldn't know about INUMs.
	309	*/
	310
3aa13a05 MV	311	SCM_API SCM SCM_MAKINUM (scm_t_signed_bits val);
3aa13a05 MV	312	SCM_API int SCM_INUMP (SCM obj);
2ad58b2a	313	#define SCM_NINUMP(x) (!SCM_INUMP(x))
3aa13a05 MV	314	SCM_API scm_t_signed_bits SCM_INUM (SCM obj);
3aa13a05 MV	315
8805b77d MV	316	#define SCM_VALIDATE_INUM(pos, k) SCM_MAKE_VALIDATE_MSG (pos, k, INUMP, "exact integer")
	317
	318	#define SCM_VALIDATE_INUM_COPY(pos, k, cvar) \
	319	do { \
3aa13a05 MV	320	SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \
3aa13a05 MV	321	cvar = SCM_I_INUM (k); \
8805b77d MV	322	} while (0)
	323
	324	#define SCM_VALIDATE_BIGINT(pos, k) SCM_MAKE_VALIDATE_MSG (pos, k, BIGP, "bignum")
	325
	326	#define SCM_VALIDATE_INUM_MIN(pos, k, min) \
	327	do { \
3aa13a05 MV	328	SCM_ASSERT (SCM_I_INUMP(k), k, pos, FUNC_NAME); \
3aa13a05 MV	329	SCM_ASSERT_RANGE (pos, k, (SCM_I_INUM (k) >= min)); \
8805b77d MV	330	} while (0)
	331
	332	#define SCM_VALIDATE_INUM_MIN_COPY(pos, k, min, cvar) \
	333	do { \
3aa13a05 MV	334	SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \
3aa13a05 MV	335	SCM_ASSERT_RANGE (pos, k, (SCM_I_INUM (k) >= min)); \
8805b77d MV	336	cvar = SCM_INUM (k); \
	337	} while (0)
	338
	339	#define SCM_VALIDATE_INUM_MIN_DEF_COPY(pos, k, min, default, cvar) \
	340	do { \
	341	if (SCM_UNBNDP (k)) \
	342	k = SCM_I_MAKINUM (default); \
3aa13a05 MV	343	SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \
3aa13a05 MV	344	SCM_ASSERT_RANGE (pos, k, (SCM_I_INUM (k) >= min)); \
8805b77d MV	345	cvar = SCM_INUM (k); \
	346	} while (0)
	347
	348	#define SCM_VALIDATE_INUM_DEF(pos, k, default) \
	349	do { \
	350	if (SCM_UNBNDP (k)) \
	351	k = SCM_I_MAKINUM (default); \
3aa13a05	352	else SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \
8805b77d MV	353	} while (0)
	354
	355	#define SCM_VALIDATE_INUM_DEF_COPY(pos, k, default, cvar) \
	356	do { \
	357	if (SCM_UNBNDP (k)) \
	358	{ \
	359	k = SCM_I_MAKINUM (default); \
	360	cvar = default; \
	361	} \
	362	else \
	363	{ \
3aa13a05	364	SCM_ASSERT (SCM_I_INUMP (k), k, pos, FUNC_NAME); \
8805b77d MV	365	cvar = SCM_INUM (k); \
	366	} \
	367	} while (0)
	368
	369	/* [low, high) */
	370	#define SCM_VALIDATE_INUM_RANGE(pos, k, low, high) \
3aa13a05	371	do { SCM_ASSERT(SCM_I_INUMP(k), k, pos, FUNC_NAME); \
8805b77d	372	SCM_ASSERT_RANGE(pos, k, \
3aa13a05 MV	373	(SCM_I_INUM (k) >= low && \
3aa13a05 MV	374	SCM_I_INUM (k) < high)); \
8805b77d MV	375	} while (0)
	376
	377	#define SCM_VALIDATE_INUM_RANGE_COPY(pos, k, low, high, cvar) \
	378	do { \
	379	SCM_ASSERT (SCM_INUMP (k), k, pos, FUNC_NAME); \
	380	SCM_ASSERT_RANGE (pos, k, low <= SCM_INUM (k) && SCM_INUM (k) < high); \
	381	cvar = SCM_INUM (k); \
	382	} while (0)
	383
c829a427 MV	384	#define SCM_STRING_COERCE_0TERMINATION_X(x) (x)
	385
	386	/* XXX - buggy interface, STR might not be large enough.
	387
	388	Converts the given Scheme string OBJ into a C string, containing a copy
	389	of OBJ's content with a trailing null byte. If LENP is non-NULL, set
	390	*LENP to the string's length.
	391
	392	When STR is non-NULL it receives the copy and is returned by the function,
	393	otherwise new memory is allocated and the caller is responsible for
	394	freeing it via free(). If out of memory, NULL is returned.
	395
	396	Note that Scheme strings may contain arbitrary data, including null
	397	characters. This means that null termination is not a reliable way to
	398	determine the length of the returned value. However, the function always
	399	copies the complete contents of OBJ, and sets *LENP to the length of the
	400	scheme string (if LENP is non-null).
	401	*/
	402	SCM_API char scm_c_string2str (SCM obj, char str, size_t *lenp);
	403
	404	/* XXX - buggy interface, you don't know how many bytes have been copied.
	405
	406	Copy LEN characters at START from the Scheme string OBJ to memory
	407	at STR. START is an index into OBJ; zero means the beginning of
	408	the string. STR has already been allocated by the caller.
	409
	410	If START + LEN is off the end of OBJ, silently truncate the source
	411	region to fit the string. If truncation occurs, the corresponding
	412	area of STR is left unchanged.
	413	*/
	414	SCM_API char scm_c_substring2str (SCM obj, char str, size_t start, size_t len);
8805b77d	415
3ee86942 MV	416	SCM_API char scm_c_symbol2str (SCM obj, char str, size_t *lenp);
3ee86942 MV	417
3101f40f MV	418	/* Deprecated because the names belong to what is now
	419	scm_truncate_number and scm_round_number.
	420	*/
	421	SCM_API double scm_truncate (double x);
	422	SCM_API double scm_round (double x);
	423
6f14f578 MV	424	/* Deprecated because we don't want people to access the internal
	425	representation of strings directly.
	426	*/
	427
	428	#define SCM_VALIDATE_STRING_COPY(pos, str, cvar) \
	429	do { \
	430	SCM_ASSERT (SCM_STRINGP (str), str, pos, FUNC_NAME); \
	431	cvar = SCM_STRING_CHARS(str); \
	432	} while (0)
	433
	434	/* validate a string and optional start/end arguments which default to
	435	0/string-len. this is unrelated to the old shared substring
	436	support, so please do not deprecate it :) */
	437	#define SCM_VALIDATE_SUBSTRING_SPEC_COPY(pos_str, str, c_str, \
	438	pos_start, start, c_start,\
	439	pos_end, end, c_end) \
	440	do {\
	441	SCM_VALIDATE_STRING_COPY (pos_str, str, c_str);\
	442	c_start = SCM_UNBNDP(start)? 0 : scm_to_size_t (start);\
	443	c_end = SCM_UNBNDP(end)? SCM_STRING_LENGTH(str) : scm_to_size_t (end);\
	444	SCM_ASSERT_RANGE (pos_start, start,\
	445	0 <= c_start \
	446	&& (size_t) c_start <= SCM_STRING_LENGTH (str));\
	447	SCM_ASSERT_RANGE (pos_end, end,\
	448	c_start <= c_end \
	449	&& (size_t) c_end <= SCM_STRING_LENGTH (str));\
	450	} while (0)
	451
3ee86942 MV	452	/* Deprecated because we don't want people to access the internals of
	453	symbols directly.
	454	*/
	455
	456	SCM_API char *SCM_SYMBOL_CHARS (SCM sym);
	457	SCM_API size_t SCM_SYMBOL_LENGTH (SCM sym);
6f14f578	458
265a7997 MV	459	/* Deprecated because the macros used to evaluate the arguments more
	460	than once and because the symbol of a keyword now has no dash.
	461	*/
	462
	463	SCM_API int SCM_KEYWORDP (SCM obj);
	464	SCM_API SCM SCM_KEYWORDSYM (SCM keyword);
	465
354116f7 MV	466	/* Deprecated because we don't want to hand out unprotected pointers
	467	to arrays, vectors, etc. */
	468
	469	#define SCM_VECTOR_MAX_LENGTH ((1L << 24) - 1)
	470
	471	SCM_API int SCM_VECTORP (SCM x);
	472	SCM_API unsigned long SCM_VECTOR_LENGTH (SCM x);
	473	SCM_API const SCM *SCM_VELTS (SCM x);
	474	SCM_API SCM *SCM_WRITABLE_VELTS (SCM x);
	475	SCM_API SCM SCM_VECTOR_REF (SCM x, size_t idx);
	476	SCM_API void SCM_VECTOR_SET (SCM x, size_t idx, SCM val);
	477	SCM_API SCM scm_vector_equal_p (SCM x, SCM y);
265a7997	478
55d30fac	479	void scm_i_init_deprecated (void);
19e2247d	480
55d30fac	481	#endif
19e2247d	482
55d30fac	483	#endif /* SCM_DEPRECATED_H */