#ifndef DAVIS_SLANG_H_ #define DAVIS_SLANG_H_ /* -*- mode: C; mode: fold; -*- */ /* Copyright (C) 2004-2021,2022 John E. Davis This file is part of the S-Lang Library. The S-Lang Library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The S-Lang 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 General Public License for more details. You should have received a copy of the GNU 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. */ #define SLANG_VERSION 20303 #define SLANG_VERSION_STRING "2.3.3" /* #ifdef __DATE__ */ /* # define SLANG_VERSION_STRING SLANG_VERSION_STRING0 " " __DATE__ */ /* #else */ /* # define SLANG_VERSION_STRING SLANG_VERSION_STRING0 */ /* #endif */ /*{{{ System Dependent Macros and Typedefs */ #if defined(__WATCOMC__) && defined(DOS) # ifndef __MSDOS__ # define __MSDOS__ # endif # ifndef DOS386 # define DOS386 # endif # ifndef IBMPC_SYSTEM # define IBMPC_SYSTEM # endif #endif /* __watcomc__ */ #if defined(unix) || defined(__unix) # ifndef __unix__ # define __unix__ 1 # endif #endif #if defined(__APPLE__) # ifndef __unix__ # define __unix__ 1 /* cough */ # endif #endif #if !defined(__GO32__) # ifdef __unix__ # define REAL_UNIX_SYSTEM # endif #endif /* Set of the various defines for pc systems. This includes OS/2 */ #ifdef __GO32__ # ifndef __DJGPP__ # define __DJGPP__ 1 # endif # ifndef IBMPC_SYSTEM # define IBMPC_SYSTEM # endif #endif #ifdef __BORLANDC__ # ifndef IBMPC_SYSTEM # define IBMPC_SYSTEM # endif #endif #ifdef __MSDOS__ # ifndef IBMPC_SYSTEM # define IBMPC_SYSTEM # endif #endif #if defined(OS2) || defined(__os2__) # ifndef IBMPC_SYSTEM # define IBMPC_SYSTEM # endif # ifndef __os2__ # define __os2__ # endif #endif #if defined(__NT__) || defined(__MINGW32__) /* || defined(__CYGWIN32__) */ # ifndef IBMPC_SYSTEM # define IBMPC_SYSTEM # endif #endif #if defined(WIN32) || defined(__WIN32__) # ifndef IBMPC_SYSTEM # define IBMPC_SYSTEM # endif # ifndef __WIN32__ # define __WIN32__ # endif #endif #if defined(IBMPC_SYSTEM) || defined(VMS) # ifdef REAL_UNIX_SYSTEM # undef REAL_UNIX_SYSTEM # endif #endif #ifdef __cplusplus extern "C" { #endif #if 0 } #endif #include #include #if defined(__STDC__) || defined(__BORLANDC__) || defined(__cplusplus) # include /* for offsetof */ #endif #ifdef SIZEOF_SHORT # define SLANG_SIZEOF_SHORT SIZEOF_SHORT #endif #ifdef SIZEOF_INT # define SLANG_SIZEOF_INT SIZEOF_INT #endif #ifdef SIZEOF_FLOAT # define SLANG_SIZEOF_FLOAT SIZEOF_FLOAT #endif #ifdef SIZEOF_DOUBLE # define SLANG_SIZEOF_DOUBLE SIZEOF_DOUBLE #endif #if !defined(SIZEOF_SHORT) || !defined(SIZEOF_INT) || !defined(SIZEOF_LONG) || !defined(SIZEOF_FLOAT) || !defined(SIZEOF_DOUBLE) # include # if !defined(SIZEOF_SHORT) && defined(SHRT_MAX) # if SHRT_MAX == 32767 # define SLANG_SIZEOF_SHORT 2 # else # if SHRT_MAX == 2147483647L # define SLANG_SIZEOF_SHORT 4 # endif # endif # endif # if !defined(SIZEOF_INT) && defined(INT_MAX) # if INT_MAX == 32767 # define SLANG_SIZEOF_INT 2 # else # if INT_MAX == 2147483647L # define SLANG_SIZEOF_INT 4 # endif # endif # endif # if !defined(SIZEOF_LONG) && defined(LONG_MAX) # if LONG_MAX == 32767 # define SLANG_SIZEOF_LONG 2 # else # if LONG_MAX == 2147483647L # define SLANG_SIZEOF_LONG 4 # else # define SLANG_SIZEOF_LONG 8 # endif # endif # endif #endif #ifndef SLANG_SIZEOF_SHORT # define SLANG_SIZEOF_SHORT 2 #endif #ifndef SLANG_SIZEOF_INT # define SLANG_SIZEOF_INT 4 #endif #ifndef SLANG_SIZEOF_LONG # define SLANG_SIZEOF_LONG 4 #endif #ifndef SLANG_SIZEOF_FLOAT # define SLANG_SIZEOF_FLOAT 4 #endif #ifndef SLANG_SIZEOF_DOUBLE # define SLANG_SIZEOF_DOUBLE 8 #endif /* ---------------------------- Generic Macros ----------------------------- */ /* __SC__ is defined for Symantec C++ DOS386 is defined for -mx memory model, 32 bit DOS extender. */ #if defined(__SC__) && !defined(DOS386) # include #endif #if defined(__BORLANDC__) # include #endif #ifdef __GNUC__ # define SLATTRIBUTE_(x) __attribute__ (x) #else # define SLATTRIBUTE_(x) #endif #define SLATTRIBUTE_PRINTF(a,b) SLATTRIBUTE_((format(printf,a,b))) #if defined (__cplusplus) || defined(__STDC__) || defined(IBMPC_SYSTEM) typedef void *VOID_STAR; #define SLCONST const #else typedef unsigned char *VOID_STAR; #define SLCONST #endif #ifdef ENABLE_SLFUTURE_CONST # define SLFUTURE_CONST SLCONST #else # define SLFUTURE_CONST #endif #ifdef ENABLE_SLFUTURE_VOID # define SLFUTURE_VOID void #else # define SLFUTURE_VOID char #endif typedef int (*FVOID_STAR)(void); typedef void (*SLFvoid_Star)(void); #if defined(__MSDOS__) && defined(__BORLANDC__) # define SLFREE(buf) farfree((void far *)(buf)) # define SLMALLOC(x) farmalloc((unsigned long) (x)) # define SLREALLOC(buf, n) farrealloc((void far *) (buf), (unsigned long) (n)) # define SLCALLOC(n, m) farcalloc((unsigned long) (n), (unsigned long) (m)) #else # if defined(VMS) && !defined(__DECC) # define SLFREE VAXC$FREE_OPT # define SLMALLOC VAXC$MALLOC_OPT # define SLREALLOC VAXC$REALLOC_OPT # define SLCALLOC VAXC$CALLOC_OPT # else # define SLFREE(x) free((char *)(x)) # define SLMALLOC malloc # define SLREALLOC realloc # define SLCALLOC calloc # endif #endif #if (defined(__WIN32__) || defined(__CYGWIN32__)) && defined(SLANG_DLL) && SLANG_DLL # define SL_EXPORT __declspec(dllexport) # define SL_IMPORT __declspec(dllimport) #else # define SL_EXPORT # define SL_IMPORT #endif #ifdef SLANG_SOURCE_ # define SL_EXTERN extern SL_EXPORT #else # define SL_EXTERN extern SL_IMPORT #endif SL_EXTERN SLFUTURE_VOID *SLdebug_malloc (unsigned long); SL_EXTERN SLFUTURE_VOID *SLdebug_calloc (unsigned long, unsigned long); SL_EXTERN SLFUTURE_VOID *SLdebug_realloc (SLFUTURE_VOID *, unsigned long); SL_EXTERN void SLdebug_free (SLFUTURE_VOID *); SL_EXTERN void SLmalloc_dump_statistics (void); SL_EXTERN char *SLstrcpy(register char *, register char *); SL_EXTERN int SLstrcmp(register char *, register char *); SL_EXTERN char *SLstrncpy(char *, register char *, register int); SL_EXTERN void SLmemset (char *, char, int); SL_EXTERN char *SLmemchr (register char *, register char, register int); SL_EXTERN char *SLmemcpy (char *, char *, int); SL_EXTERN int SLmemcmp (char *, char *, int); /*}}}*/ typedef unsigned int SLstrlen_Type; /* Eventually this will become size_t */ #define SLANG_STRLEN_TYPE SLANG_UINT_TYPE typedef int SLindex_Type; typedef unsigned int SLuindex_Type; #define SLANG_ARRAY_INDEX_TYPE SLANG_INT_TYPE /* SLstrings */ typedef char SLstr_Type; SL_EXTERN int SLang_pop_strlen_type (SLstrlen_Type *); SL_EXTERN int SLang_push_strlen_type (SLstrlen_Type); /* An SLstr_Type object must be treated as a constant and may only be freed * by the SLang_free_slstring function and nothing else. */ SL_EXTERN SLstr_Type *SLang_create_nslstring (SLFUTURE_CONST char *, SLstrlen_Type); SL_EXTERN SLstr_Type *SLang_create_slstring (SLFUTURE_CONST char *); SL_EXTERN void SLang_free_slstring (SLCONST SLstr_Type *); /* handles NULL */ SL_EXTERN int SLang_pop_slstring (SLstr_Type **); /* free with SLang_free_slstring */ SL_EXTERN SLstr_Type *SLang_concat_slstrings (SLstr_Type *a, SLstr_Type *b); typedef unsigned long SLstr_Hash_Type; SL_EXTERN SLstr_Hash_Type SLcompute_string_hash (SLCONST SLstr_Type *); /* SL_EXTERN void SLstring_dump_stats (void); // is not (yet?) defined by S-Lang library */ /*{{{ UTF-8 and Wide Char support */ #if SLANG_SIZEOF_INT == 4 typedef unsigned int SLwchar_Type; # define SLANG_WCHAR_TYPE SLANG_UINT_TYPE # define SLang_push_wchar SLang_push_uint # define SLang_pop_wchar SLang_pop_uint #else typedef unsigned long SLwchar_Type; # define SLANG_WCHAR_TYPE SLANG_ULONG_TYPE # define SLang_push_wchar SLang_push_ulong # define SLang_pop_wchar SLang_pop_ulong #endif typedef unsigned char SLuchar_Type; /* Maximum multi-byte len for a unicode wchar */ #define SLUTF8_MAX_MBLEN 6 /* If argument is 1, force UTF-8 mode on. If argument is 0, force mode off. * If -1, determine mode from the locale. * Returns 1 if enabled, 0 if not. */ SL_EXTERN int SLutf8_enable (int); SL_EXTERN int SLutf8_is_utf8_mode (void); SL_EXTERN int SLtt_utf8_enable (int); SL_EXTERN int SLtt_is_utf8_mode (void); SL_EXTERN int SLsmg_utf8_enable (int); SL_EXTERN int SLsmg_is_utf8_mode (void); SL_EXTERN int SLinterp_utf8_enable (int); SL_EXTERN int SLinterp_is_utf8_mode (void); SL_EXTERN SLwchar_Type SLwchar_toupper (SLwchar_Type); SL_EXTERN SLwchar_Type SLwchar_tolower (SLwchar_Type); SL_EXTERN int SLwchar_wcwidth (SLwchar_Type); SL_EXTERN int SLwchar_isalnum (SLwchar_Type); SL_EXTERN int SLwchar_isalpha (SLwchar_Type); SL_EXTERN int SLwchar_isblank (SLwchar_Type); SL_EXTERN int SLwchar_iscntrl (SLwchar_Type); SL_EXTERN int SLwchar_isdigit (SLwchar_Type); SL_EXTERN int SLwchar_isgraph (SLwchar_Type); SL_EXTERN int SLwchar_islower (SLwchar_Type); SL_EXTERN int SLwchar_isprint (SLwchar_Type); SL_EXTERN int SLwchar_ispunct (SLwchar_Type); SL_EXTERN int SLwchar_isspace (SLwchar_Type); SL_EXTERN int SLwchar_isupper (SLwchar_Type); SL_EXTERN int SLwchar_isxdigit (SLwchar_Type); #define SLWCWIDTH_SINGLE_WIDTH 0x0001 /* all double width characters given as single width */ #define SLWCWIDTH_CJK_LEGACY 0x0002 /* Ambiguous characters given width of 2 */ SL_EXTERN int SLwchar_set_wcwidth_flags (int flags); /* The skip_char functions also skip over malformed strings counting each byte * in the malformed sequence. */ SL_EXTERN SLuchar_Type *SLutf8_skip_char (SLuchar_Type *u, SLuchar_Type *umax); SL_EXTERN SLuchar_Type *SLutf8_bskip_char (SLuchar_Type *umin, SLuchar_Type *u); SL_EXTERN SLuchar_Type *SLutf8_skip_chars (SLuchar_Type *u, SLuchar_Type *umax, SLstrlen_Type num, SLstrlen_Type *dnum, int ignore_combining ); SL_EXTERN SLuchar_Type *SLutf8_bskip_chars (SLuchar_Type *umin, SLuchar_Type *u, SLstrlen_Type num, SLstrlen_Type *dnum, int ignore_combining); /* The SLutf8_strup/lo functions return slstrings -- free with SLang_free_slstring */ SL_EXTERN SLuchar_Type *SLutf8_strup (SLuchar_Type *u, SLuchar_Type *umax); SL_EXTERN SLuchar_Type *SLutf8_strlo (SLuchar_Type *u, SLuchar_Type *umax); SL_EXTERN SLstr_Type *SLutf8_subst_wchar (SLuchar_Type *u, SLuchar_Type *umax, SLwchar_Type wch, SLstrlen_Type pos, int ignore_combining); SL_EXTERN SLstrlen_Type SLutf8_strlen (SLuchar_Type *s, int ignore_combining); SL_EXTERN SLuchar_Type *SLutf8_decode (SLuchar_Type *u, SLuchar_Type *umax, SLwchar_Type *w, SLstrlen_Type *nconsumedp); SL_EXTERN SLuchar_Type *SLutf8_encode (SLwchar_Type w, SLuchar_Type *u, SLstrlen_Type ulen); SL_EXTERN int SLutf8_compare (SLuchar_Type *a, SLuchar_Type *amax, SLuchar_Type *b, SLuchar_Type *bmax, SLstrlen_Type nchars, int case_sensitive); /* In these functions, buf is assumed to contain at least SLUTF8_MAX_MBLEN+1 * bytes */ SL_EXTERN SLuchar_Type *SLutf8_extract_utf8_char (SLuchar_Type *u, SLuchar_Type *umax, SLuchar_Type *buf); SL_EXTERN SLuchar_Type *SLutf8_encode_null_terminate (SLwchar_Type w, SLuchar_Type *buf); typedef struct SLwchar_Lut_Type SLwchar_Lut_Type; SL_EXTERN SLwchar_Lut_Type *SLwchar_create_lut (unsigned int num_entries); SL_EXTERN int SLwchar_add_range_to_lut (SLwchar_Lut_Type *r, SLwchar_Type a, SLwchar_Type b); SL_EXTERN SLuchar_Type *SLwchar_skip_range (SLwchar_Lut_Type *r, SLuchar_Type *p, SLuchar_Type *pmax, int ignore_combining, int invert); SL_EXTERN SLwchar_Lut_Type *SLwchar_strtolut (SLuchar_Type *u, int allow_range, int allow_charclass); SL_EXTERN void SLwchar_free_lut (SLwchar_Lut_Type *r); SL_EXTERN SLuchar_Type *SLwchar_bskip_range (SLwchar_Lut_Type *r, SLuchar_Type *pmin, SLuchar_Type *p, int ignore_combining, int invert); SL_EXTERN int SLwchar_in_lut (SLwchar_Lut_Type *r, SLwchar_Type wch); typedef struct SLwchar_Map_Type SLwchar_Map_Type; SL_EXTERN void SLwchar_free_char_map (SLwchar_Map_Type *map); SL_EXTERN SLwchar_Map_Type *SLwchar_allocate_char_map (SLuchar_Type *from, SLuchar_Type *to); SL_EXTERN int SLwchar_apply_char_map (SLwchar_Map_Type *map, SLwchar_Type *input, SLwchar_Type *output, unsigned int num); /* This function returns a malloced string */ SLuchar_Type *SLuchar_apply_char_map (SLwchar_Map_Type *map, SLuchar_Type *str); /*}}}*/ /*{{{ Interpreter Typedefs */ typedef unsigned int SLtype; #define SLANG_SLTYPE_INT_TYPE SLANG_UINT_TYPE typedef struct _pSLang_Name_Type { SLFUTURE_CONST char *name; struct _pSLang_Name_Type *next; unsigned char name_type; /* These values here map directly to byte codes. See _slang.h. */ #define SLANG_LVARIABLE 0x01 #define SLANG_GVARIABLE 0x02 #define SLANG_IVARIABLE 0x03 /* intrinsic variables */ /* Note!!! For Macro MAKE_VARIABLE below to work, SLANG_IVARIABLE Must be 1 less than SLANG_RVARIABLE!!! */ #define SLANG_RVARIABLE 0x04 /* read only variable */ #define SLANG_INTRINSIC 0x05 #define SLANG_FUNCTION 0x06 #define SLANG_MATH_UNARY 0x07 #define SLANG_APP_UNARY 0x08 #define SLANG_ARITH_UNARY 0x09 /* private */ #define SLANG_ARITH_BINARY 0x0A #define SLANG_ICONSTANT 0x0B #define SLANG_DCONSTANT 0x0C #define SLANG_FCONSTANT 0x0D #define SLANG_LLCONSTANT 0x0E #define SLANG_PVARIABLE 0x0F /* private */ #define SLANG_PFUNCTION 0x10 /* private */ #define SLANG_HCONSTANT 0x11 #define SLANG_LCONSTANT 0x12 /* Rest of fields depend on name type */ } SLang_Name_Type; typedef struct { SLFUTURE_CONST char *name; struct _pSLang_Name_Type *next; /* this is for the hash table */ char name_type; FVOID_STAR i_fun; /* address of object */ /* Do not change this without modifying slang.c:execute_intrinsic_fun */ #define SLANG_MAX_INTRIN_ARGS 7 SLtype arg_types [SLANG_MAX_INTRIN_ARGS]; unsigned char num_args; SLtype return_type; } SLang_Intrin_Fun_Type; typedef struct { SLFUTURE_CONST char *name; SLang_Name_Type *next; char name_type; VOID_STAR addr; SLtype type; } SLang_Intrin_Var_Type; typedef struct { SLFUTURE_CONST char *name; SLang_Name_Type *next; char name_type; int unary_op; } SLang_App_Unary_Type; typedef struct { SLFUTURE_CONST char *name; SLang_Name_Type *next; char name_type; int unary_op; } SLang_Math_Unary_Type; typedef struct { SLFUTURE_CONST char *name; SLang_Name_Type *next; char name_type; SLtype data_type; short value; } SLang_HConstant_Type; typedef struct { SLFUTURE_CONST char *name; SLang_Name_Type *next; char name_type; SLtype data_type; int value; } SLang_IConstant_Type; typedef struct { SLFUTURE_CONST char *name; SLang_Name_Type *next; char name_type; SLtype data_type; long value; } SLang_LConstant_Type; #ifdef HAVE_LONG_LONG typedef struct { SLFUTURE_CONST char *name; SLang_Name_Type *next; char name_type; long long ll; } SLang_LLConstant_Type; #endif typedef struct { SLFUTURE_CONST char *name; SLang_Name_Type *next; char name_type; double d; } SLang_DConstant_Type; typedef struct { SLFUTURE_CONST char *name; SLang_Name_Type *next; char name_type; float f; } SLang_FConstant_Type; typedef struct { SLFUTURE_CONST char *field_name; /* gets replaced by slstring at run-time */ unsigned int offset; SLtype type; unsigned char read_only; } SLang_IStruct_Field_Type; typedef SLCONST struct _pSLang_CStruct_Field_Type /* a g++ bug?? yuk*/ { SLFUTURE_CONST char *field_name; unsigned int offset; SLtype type; unsigned char read_only; } SLang_CStruct_Field_Type; SL_EXTERN int SLadd_intrin_fun_table (SLang_Intrin_Fun_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLadd_intrin_var_table (SLang_Intrin_Var_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLadd_app_unary_table (SLang_App_Unary_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLadd_math_unary_table (SLang_Math_Unary_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLadd_iconstant_table (SLang_IConstant_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLadd_lconstant_table (SLang_LConstant_Type *, SLFUTURE_CONST char *pp); SL_EXTERN int SLadd_dconstant_table (SLang_DConstant_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLadd_fconstant_table (SLang_FConstant_Type *, SLFUTURE_CONST char *); #ifdef HAVE_LONG_LONG SL_EXTERN int SLadd_llconstant_table (SLang_LLConstant_Type *, SLFUTURE_CONST char *); #endif SL_EXTERN int SLadd_istruct_table (SLang_IStruct_Field_Type *, VOID_STAR, SLFUTURE_CONST char *); typedef struct _pSLang_NameSpace_Type SLang_NameSpace_Type; SL_EXTERN int SLns_add_intrin_fun_table (SLang_NameSpace_Type *, SLang_Intrin_Fun_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLns_add_intrin_var_table (SLang_NameSpace_Type *, SLang_Intrin_Var_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLns_add_app_unary_table (SLang_NameSpace_Type *, SLang_App_Unary_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLns_add_math_unary_table (SLang_NameSpace_Type *, SLang_Math_Unary_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLns_add_hconstant_table (SLang_NameSpace_Type *, SLang_HConstant_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLns_add_iconstant_table (SLang_NameSpace_Type *, SLang_IConstant_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLns_add_lconstant_table (SLang_NameSpace_Type *, SLang_LConstant_Type *, SLFUTURE_CONST char *); /* SL_EXTERN int SLns_add_fconstant_table (SLang_NameSpace_Type *, SLang_FConstant_Type *, SLFUTURE_CONST char *); // is not (yet?) defined by S-Lang library */ SL_EXTERN int SLns_add_dconstant_table (SLang_NameSpace_Type *, SLang_DConstant_Type *, SLFUTURE_CONST char *); #ifdef HAVE_LONG_LONG /* SL_EXTERN int SLns_add_llconstant_table (SLang_NameSpace_Type *, SLang_LLConstant_Type *, SLFUTURE_CONST char *); // is not (yet?) defined by S-Lang library */ #endif SL_EXTERN int SLns_add_istruct_table (SLang_NameSpace_Type *, SLang_IStruct_Field_Type *, VOID_STAR, SLFUTURE_CONST char *); SL_EXTERN int SLns_add_hconstant (SLang_NameSpace_Type *, SLFUTURE_CONST char *, SLtype, short); SL_EXTERN int SLns_add_iconstant (SLang_NameSpace_Type *, SLFUTURE_CONST char *, SLtype, int); SL_EXTERN int SLns_add_lconstant (SLang_NameSpace_Type *, SLFUTURE_CONST char *, SLtype, long); SL_EXTERN int SLns_add_fconstant (SLang_NameSpace_Type *, SLFUTURE_CONST char *, float); SL_EXTERN int SLns_add_dconstant (SLang_NameSpace_Type *, SLFUTURE_CONST char *, double); #ifdef HAVE_LONG_LONG SL_EXTERN int SLns_add_llconstant (SLang_NameSpace_Type *, SLFUTURE_CONST char *, long long); #endif SL_EXTERN SLang_NameSpace_Type *SLns_create_namespace (SLFUTURE_CONST char *); SL_EXTERN void SLns_delete_namespace (SLang_NameSpace_Type *); SL_EXTERN int SLns_load_file (SLFUTURE_CONST char *, SLFUTURE_CONST char *); SL_EXTERN int SLns_load_string (SLFUTURE_CONST char *, SLFUTURE_CONST char *); SL_EXTERN int (*SLns_Load_File_Hook) (SLFUTURE_CONST char *, SLFUTURE_CONST char *); #define SLANG_LOAD_FILE_VERBOSE 0x1 #define SLANG_LOAD_MODULE_VERBOSE 0x2 SL_EXTERN int SLang_load_file_verbose (int); /* Bitmapped value that controls loading messages */ typedef struct SLang_Load_Type { int type; VOID_STAR client_data; /* Pointer to data that client needs for loading */ int auto_declare_globals; /* if non-zero, undefined global variables are declared as static */ char *(*read)(struct SLang_Load_Type *); /* function to call to read next line from obj. */ unsigned int line_num; /* Number of lines read, used for error reporting */ int parse_level; /* 0 if at top level of parsing */ SLFUTURE_CONST char *name; /* Name of this object, e.g., filename. This name should be unique because * it alone determines the name space for static objects associated with * the compilable unit. */ SLFUTURE_CONST char *namespace_name; unsigned long reserved[3]; /* For future expansion */ } SLang_Load_Type; SL_EXTERN SLang_Load_Type *SLallocate_load_type (SLFUTURE_CONST char *); SL_EXTERN void SLdeallocate_load_type (SLang_Load_Type *); SL_EXTERN SLang_Load_Type *SLns_allocate_load_type (SLFUTURE_CONST char *, SLFUTURE_CONST char *); /* Returns SLang_Error upon failure */ SL_EXTERN int SLang_load_object (SLang_Load_Type *); SL_EXTERN int (*SLang_Load_File_Hook)(SLFUTURE_CONST char *); SL_EXTERN int (*SLang_Auto_Declare_Var_Hook) (SLFUTURE_CONST char *); SL_EXTERN int SLang_generate_debug_info (int); #if defined(ultrix) && !defined(__GNUC__) # ifndef NO_PROTOTYPES # define NO_PROTOTYPES # endif #endif #ifndef NO_PROTOTYPES # define _PROTO(x) x #else # define _PROTO(x) () #endif SL_EXTERN int SLang_pop_array_index (SLindex_Type *); SL_EXTERN int SLang_push_array_index (SLindex_Type); typedef struct _pSLang_Struct_Type SLang_Struct_Type; SL_EXTERN void SLang_free_struct (SLang_Struct_Type *); SL_EXTERN int SLang_push_struct (SLang_Struct_Type *); SL_EXTERN int SLang_pop_struct (SLang_Struct_Type **); SL_EXTERN SLang_Struct_Type *SLang_create_struct (SLFUTURE_CONST char **field_names, unsigned int nfields); /* Push the specified field value onto the stack */ SL_EXTERN int SLang_push_struct_field (SLang_Struct_Type *s, char *name); /* Pop the value from the stack into the specified field */ SL_EXTERN int SLang_pop_struct_field (SLang_Struct_Type *s, char *name); /* Set the first n fields of the struct from the stack. If n < 0, pop all fields. */ SL_EXTERN int SLang_pop_struct_fields (SLang_Struct_Type *s, int n); typedef struct _pSLang_Assoc_Array_Type SLang_Assoc_Array_Type; SL_EXTERN SLang_Assoc_Array_Type *SLang_create_assoc (SLtype type, int has_default); /* If has_default is non-zero, take the default value from the stack */ SL_EXTERN void SLang_free_assoc (SLang_Assoc_Array_Type *); SL_EXTERN int SLang_push_assoc (SLang_Assoc_Array_Type *, int free_flag); SL_EXTERN int SLang_pop_assoc (SLang_Assoc_Array_Type **); SL_EXTERN int SLang_assoc_get (SLang_Assoc_Array_Type *, SLstr_Type *, SLtype *); /* SLang_assoc_get leaves the object on the stack */ SL_EXTERN int SLang_assoc_put (SLang_Assoc_Array_Type *, SLstr_Type *); /* SLang_assoc_put takes the object from the stack */ SL_EXTERN int SLang_assoc_key_exists (SLang_Assoc_Array_Type *, SLstr_Type *); typedef struct _pSLang_List_Type SLang_List_Type; SL_EXTERN SLang_List_Type *SLang_create_list (int); SL_EXTERN int SLang_list_append (SLang_List_Type *, int); SL_EXTERN int SLang_list_insert (SLang_List_Type *, int); SL_EXTERN int SLang_push_list (SLang_List_Type *, int free_list); SL_EXTERN int SLang_pop_list (SLang_List_Type **); SL_EXTERN void SLang_free_list (SLang_List_Type *); typedef struct _pSLang_Foreach_Context_Type SLang_Foreach_Context_Type; typedef struct _pSLang_Class_Type SLang_Class_Type; /* These are the low-level functions for building push/pop methods. They * know nothing about memory management. For SLANG_CLASS_TYPE_MMT, use the * MMT push/pop functions instead. */ SL_EXTERN int SLclass_push_double_obj (SLtype, double); SL_EXTERN int SLclass_push_float_obj (SLtype, float); SL_EXTERN int SLclass_push_long_obj (SLtype, long); SL_EXTERN int SLclass_push_int_obj (SLtype, int); SL_EXTERN int SLclass_push_short_obj (SLtype, short); SL_EXTERN int SLclass_push_char_obj (SLtype, char); SL_EXTERN int SLclass_push_ptr_obj (SLtype, VOID_STAR); SL_EXTERN int SLclass_pop_double_obj (SLtype, double *); SL_EXTERN int SLclass_pop_float_obj (SLtype, float *); SL_EXTERN int SLclass_pop_long_obj (SLtype, long *); SL_EXTERN int SLclass_pop_int_obj (SLtype, int *); SL_EXTERN int SLclass_pop_short_obj (SLtype, short *); SL_EXTERN int SLclass_pop_char_obj (SLtype, char *); SL_EXTERN int SLclass_pop_ptr_obj (SLtype, VOID_STAR *); #ifdef HAVE_LONG_LONG SL_EXTERN int SLang_pop_long_long (long long *); SL_EXTERN int SLang_push_long_long (long long); SL_EXTERN int SLang_pop_ulong_long (unsigned long long *); SL_EXTERN int SLang_push_ulong_long (unsigned long long); /* SL_EXTERN int SLclass_pop_llong_obj (SLtype, long long *); // is not (yet?) defined by S-Lang library */ SL_EXTERN int SLclass_push_llong_obj (SLtype, long long); #endif SL_EXTERN SLang_Class_Type *SLclass_allocate_class (SLFUTURE_CONST char *); SL_EXTERN int SLclass_get_class_id (SLang_Class_Type *cl); SL_EXTERN int SLclass_create_synonym (SLFUTURE_CONST char *, SLtype); SL_EXTERN int SLclass_is_class_defined (SLtype); SL_EXTERN int SLclass_dup_object (SLtype type, VOID_STAR from, VOID_STAR to); typedef int SLclass_Type; #define SLANG_CLASS_TYPE_MMT 0 #define SLANG_CLASS_TYPE_SCALAR 1 #define SLANG_CLASS_TYPE_VECTOR 2 #define SLANG_CLASS_TYPE_PTR 3 SL_EXTERN int SLclass_register_class (SLang_Class_Type *, SLtype, unsigned int, SLclass_Type); SL_EXTERN int SLclass_set_string_function (SLang_Class_Type *, char *(*)(SLtype, VOID_STAR)); SL_EXTERN int SLclass_set_destroy_function (SLang_Class_Type *, void (*)(SLtype, VOID_STAR)); SL_EXTERN int SLclass_set_push_function (SLang_Class_Type *, int (*)(SLtype, VOID_STAR)); SL_EXTERN int SLclass_set_apush_function (SLang_Class_Type *, int (*)(SLtype, VOID_STAR)); SL_EXTERN int SLclass_set_pop_function (SLang_Class_Type *, int (*)(SLtype, VOID_STAR)); SL_EXTERN int SLclass_set_aget_function (SLang_Class_Type *, int (*)(SLtype, unsigned int)); SL_EXTERN int SLclass_set_aput_function (SLang_Class_Type *, int (*)(SLtype, unsigned int)); SL_EXTERN int SLclass_set_anew_function (SLang_Class_Type *, int (*)(SLtype, unsigned int)); SL_EXTERN int SLclass_set_sget_function (SLang_Class_Type *, int (*)(SLtype, SLFUTURE_CONST char *)); SL_EXTERN int SLclass_set_sput_function (SLang_Class_Type *, int (*)(SLtype, SLFUTURE_CONST char *)); SL_EXTERN int SLclass_set_acopy_function (SLang_Class_Type *, int (*)(SLtype, VOID_STAR, VOID_STAR)); SL_EXTERN int SLclass_set_deref_function (SLang_Class_Type *, int (*)(SLtype, VOID_STAR)); SL_EXTERN int SLclass_set_eqs_function (SLang_Class_Type *, int (*)(SLtype, VOID_STAR, SLtype, VOID_STAR)); SL_EXTERN int SLclass_set_length_function (SLang_Class_Type *, int(*)(SLtype, VOID_STAR, SLuindex_Type *)); SL_EXTERN int SLclass_set_is_container (SLang_Class_Type *, int); SL_EXTERN int SLclass_set_foreach_functions ( SLang_Class_Type *, SLang_Foreach_Context_Type *(*)(SLtype, unsigned int), /* open method */ int (*)(SLtype, SLang_Foreach_Context_Type *), /* foreach method */ void (*)(SLtype, SLang_Foreach_Context_Type *));/* close method */ /* When an array is created, this callback function is called to initialize the data * at the specified address. */ SL_EXTERN int SLclass_set_aelem_init_function (SLang_Class_Type *cl, int (*f)(SLtype, VOID_STAR)); /* Typecast object on the stack to type p1. p2 and p3 should be set to 1 */ SL_EXTERN int SLclass_typecast (SLtype, int, int); #define SLMATH_SIN 1 #define SLMATH_COS 2 #define SLMATH_TAN 3 #define SLMATH_ATAN 4 #define SLMATH_ASIN 5 #define SLMATH_ACOS 6 #define SLMATH_EXP 7 #define SLMATH_LOG 8 #define SLMATH_SQRT 9 #define SLMATH_LOG10 10 #define SLMATH_REAL 11 #define SLMATH_IMAG 12 #define SLMATH_SINH 13 #define SLMATH_COSH 14 #define SLMATH_TANH 15 #define SLMATH_ATANH 16 #define SLMATH_ASINH 17 #define SLMATH_ACOSH 18 #define SLMATH_TODOUBLE 19 #define SLMATH_CONJ 20 #define SLMATH_ISINF 21 #define SLMATH_ISNAN 22 #define SLMATH_FLOOR 23 #define SLMATH_CEIL 24 #define SLMATH_ROUND 25 #define SLMATH_EXPM1 26 #define SLMATH_LOG1P 27 SL_EXTERN int SLclass_add_unary_op (SLtype, int (*) (int, SLtype, VOID_STAR, SLuindex_Type, VOID_STAR), int (*) (int, SLtype, SLtype *)); SL_EXTERN int SLclass_add_app_unary_op (SLtype, int (*) (int, SLtype, VOID_STAR, SLuindex_Type, VOID_STAR), int (*) (int, SLtype, SLtype *)); SL_EXTERN int SLclass_add_binary_op (SLtype, SLtype, int (*) (int, SLtype, VOID_STAR, SLuindex_Type, SLtype, VOID_STAR, SLuindex_Type, VOID_STAR), int (*) (int, SLtype, SLtype, SLtype *)); SL_EXTERN int SLclass_add_math_op (SLtype, int (*)(int, SLtype, VOID_STAR, SLuindex_Type, VOID_STAR), int (*)(int, SLtype, SLtype *)); SL_EXTERN int SLclass_add_typecast (SLtype /* from */, SLtype /* to */, int (*)_PROTO((SLtype, VOID_STAR, SLuindex_Type, SLtype, VOID_STAR)), int /* allow implicit typecasts */ ); SL_EXTERN SLFUTURE_CONST char *SLclass_get_datatype_name (SLtype); SL_EXTERN double SLcomplex_abs (double *); SL_EXTERN double *SLcomplex_times (double *, double *, double *); SL_EXTERN double *SLcomplex_divide (double *, double *, double *); SL_EXTERN double *SLcomplex_sin (double *, double *); SL_EXTERN double *SLcomplex_cos (double *, double *); SL_EXTERN double *SLcomplex_tan (double *, double *); SL_EXTERN double *SLcomplex_asin (double *, double *); SL_EXTERN double *SLcomplex_acos (double *, double *); SL_EXTERN double *SLcomplex_atan (double *, double *); SL_EXTERN double *SLcomplex_exp (double *, double *); SL_EXTERN double *SLcomplex_log (double *, double *); SL_EXTERN double *SLcomplex_log10 (double *, double *); SL_EXTERN double *SLcomplex_sqrt (double *, double *); SL_EXTERN double *SLcomplex_sinh (double *, double *); SL_EXTERN double *SLcomplex_cosh (double *, double *); SL_EXTERN double *SLcomplex_tanh (double *, double *); SL_EXTERN double *SLcomplex_pow (double *, double *, double *); SL_EXTERN double SLmath_hypot (double x, double y); /* Not implemented yet */ SL_EXTERN double *SLcomplex_asinh (double *, double *); SL_EXTERN double *SLcomplex_acosh (double *, double *); SL_EXTERN double *SLcomplex_atanh (double *, double *); #ifdef SLANG_SOURCE_ typedef struct _pSLang_MMT_Type SLang_MMT_Type; #else typedef int SLang_MMT_Type; #endif SL_EXTERN void SLang_free_mmt (SLang_MMT_Type *); SL_EXTERN VOID_STAR SLang_object_from_mmt (SLang_MMT_Type *); SL_EXTERN SLang_MMT_Type *SLang_create_mmt (SLtype, VOID_STAR); SL_EXTERN int SLang_push_mmt (SLang_MMT_Type *); SL_EXTERN SLang_MMT_Type *SLang_pop_mmt (SLtype); SL_EXTERN void SLang_inc_mmt (SLang_MMT_Type *); /* Maximum number of dimensions of an array. */ #define SLARRAY_MAX_DIMS 7 typedef struct _pSLang_Array_Type { SLtype data_type; unsigned int sizeof_type; VOID_STAR data; SLuindex_Type num_elements; unsigned int num_dims; SLindex_Type dims [SLARRAY_MAX_DIMS]; VOID_STAR (*index_fun)_PROTO((struct _pSLang_Array_Type *, SLindex_Type *)); /* This function is designed to allow a type to store an array in * any manner it chooses. This function returns the address of the data * value at the specified index location. */ unsigned int flags; #define SLARR_DATA_VALUE_IS_READ_ONLY 0x0001 #define SLARR_DATA_VALUE_IS_POINTER 0x0002 #define SLARR_DATA_VALUE_IS_RANGE 0x0004 #define SLARR_DATA_VALUE_IS_INTRINSIC 0x0008 #define SLARR_DERIVED_FROM_SCALAR 0x0100 SLang_Class_Type *cl; unsigned int num_refs; void (*free_fun)_PROTO((struct _pSLang_Array_Type *)); VOID_STAR client_data; } SLang_Array_Type; SL_EXTERN int _pSLarray_convert_to_array (VOID_STAR cd, int (*get_type)(VOID_STAR, SLuindex_Type, SLtype *), int (*push)(VOID_STAR, SLuindex_Type), SLuindex_Type num_objects, SLtype type); SL_EXTERN int SLang_pop_array_of_type (SLang_Array_Type **atp, SLtype type); SL_EXTERN int SLang_pop_array (SLang_Array_Type **atp, int convert_scalar); SL_EXTERN int SLang_push_array (SLang_Array_Type *at, int do_free); SL_EXTERN void SLang_free_array (SLang_Array_Type *at); SL_EXTERN SLang_Array_Type *SLang_create_array (SLtype, int, VOID_STAR, SLindex_Type *, unsigned int); SL_EXTERN SLang_Array_Type *SLang_create_array1 (SLtype, int, VOID_STAR, SLindex_Type *, unsigned int, int); SL_EXTERN SLang_Array_Type *SLang_duplicate_array (SLang_Array_Type *); SL_EXTERN int SLang_get_array_element (SLang_Array_Type *, SLindex_Type *, VOID_STAR); SL_EXTERN int SLang_set_array_element (SLang_Array_Type *, SLindex_Type *, VOID_STAR); typedef int SLarray_Contract_Fun_Type (VOID_STAR xp, unsigned int increment, unsigned int num, VOID_STAR yp); typedef struct { SLtype from_type; /* if array is this type */ SLtype typecast_to_type; /* typecast it to this */ SLtype result_type; /* to produce this */ SLarray_Contract_Fun_Type *f; /* via this function */ } SLarray_Contract_Type; SL_EXTERN int SLarray_contract_array (SLCONST SLarray_Contract_Type *); typedef int SLarray_Map_Fun_Type (SLtype xtype, VOID_STAR xp, unsigned int increment, unsigned int num, SLtype ytype, VOID_STAR yp, VOID_STAR clientdata); typedef struct { SLtype from_type; /* if array is this type */ SLtype typecast_to_type; /* typecast it to this */ SLtype result_type; /* to produce this */ SLarray_Map_Fun_Type *f; /* via this function */ } SLarray_Map_Type; SL_EXTERN int SLarray_map_array_1 (SLCONST SLarray_Map_Type *, int *use_this_dim, VOID_STAR clientdata); SL_EXTERN int SLarray_map_array (SLCONST SLarray_Map_Type *); /*}}}*/ /*{{{ Interpreter Function Prototypes */ SL_EXTERN int SLerr_throw (int err, SLFUTURE_CONST char *msg, SLtype obj_type, VOID_STAR objptr); SL_EXTERN void SLang_verror (int, SLFUTURE_CONST char *, ...) SLATTRIBUTE_PRINTF(2,3); SL_EXTERN void SLang_verror_va (int errcode, SLFUTURE_CONST char *fmt, va_list va); SL_EXTERN int SLang_get_error (void); SL_EXTERN int SLang_set_error (int); SL_EXTERN SLFUTURE_CONST char *SLerr_strerror (int errcode); SL_EXTERN int SLerr_new_exception (int baseclass, SLFUTURE_CONST char *name, SLFUTURE_CONST char *descript); SL_EXTERN int SLerr_exception_eqs (int, int); SL_EXTERN int SL_Any_Error; SL_EXTERN int SL_OS_Error; SL_EXTERN int SL_Malloc_Error; SL_EXTERN int SL_IO_Error; SL_EXTERN int SL_Write_Error; SL_EXTERN int SL_Read_Error; SL_EXTERN int SL_Open_Error; SL_EXTERN int SL_RunTime_Error; SL_EXTERN int SL_InvalidParm_Error; SL_EXTERN int SL_TypeMismatch_Error; SL_EXTERN int SL_UserBreak_Error; SL_EXTERN int SL_Stack_Error; SL_EXTERN int SL_StackOverflow_Error; SL_EXTERN int SL_StackUnderflow_Error; SL_EXTERN int SL_ReadOnly_Error; SL_EXTERN int SL_VariableUninitialized_Error; SL_EXTERN int SL_NumArgs_Error; SL_EXTERN int SL_Index_Error; SL_EXTERN int SL_Parse_Error; SL_EXTERN int SL_Syntax_Error; SL_EXTERN int SL_DuplicateDefinition_Error; SL_EXTERN int SL_UndefinedName_Error; SL_EXTERN int SL_Usage_Error; SL_EXTERN int SL_Application_Error; SL_EXTERN int SL_Internal_Error; SL_EXTERN int SL_NotImplemented_Error; SL_EXTERN int SL_LimitExceeded_Error; SL_EXTERN int SL_Forbidden_Error; SL_EXTERN int SL_Math_Error; SL_EXTERN int SL_DivideByZero_Error; SL_EXTERN int SL_ArithOverflow_Error; SL_EXTERN int SL_ArithUnderflow_Error; SL_EXTERN int SL_Domain_Error; SL_EXTERN int SL_Data_Error; SL_EXTERN int SL_Unicode_Error; SL_EXTERN int SL_InvalidUTF8_Error; SL_EXTERN int SL_Namespace_Error; SL_EXTERN int SL_Unknown_Error; SL_EXTERN int SL_Import_Error; /* Non zero if error occurs. Must be reset to zero to continue. */ /* Compatibility */ #define USER_BREAK SL_UserBreak_Error #define INTRINSIC_ERROR SL_RunTime_Error #define SL_OBJ_NOPEN SL_Open_Error #define SL_UNKNOWN_ERROR SL_Unknown_Error #define SL_APPLICATION_ERROR SL_Application_Error #define SL_INTERNAL_ERROR SL_Internal_Error #define SL_INTRINSIC_ERROR SL_RunTime_Error #define SL_NOT_IMPLEMENTED SL_NotImplemented_Error #define SL_BUILTIN_LIMIT_EXCEEDED SL_LimitExceeded_Error #define SL_MALLOC_ERROR SL_Malloc_Error #define SL_USER_BREAK SL_UserBreak_Error #define SL_IO_WRITE_ERROR SL_Write_Error #define SL_IO_READ_ERROR SL_Read_Error #define SL_IO_OPEN_ERROR SL_Open_Error #define SL_SYNTAX_ERROR SL_Syntax_Error #define SL_STACK_OVERFLOW SL_StackOverflow_Error #define SL_STACK_UNDERFLOW SL_StackUnderflow_Error #define SL_TYPE_MISMATCH SL_TypeMismatch_Error #define SL_READONLY_ERROR SL_ReadOnly_Error #define SL_VARIABLE_UNINITIALIZED SL_VariableUninitialized_Error #define SL_DUPLICATE_DEFINITION SL_DuplicateDefinition_Error #define SL_INVALID_PARM SL_InvalidParm_Error #define SL_UNDEFINED_NAME SL_UndefinedName_Error #define SL_NUM_ARGS_ERROR SL_NumArgs_Error #define SL_INDEX_ERROR SL_Index_Error #define SL_DIVIDE_ERROR SL_DivideByZero_Error #define SL_MATH_ERROR SL_Math_Error #define SL_ARITH_OVERFLOW_ERROR SL_ArithOverflow_Error #define SL_ARITH_UNDERFLOW_ERROR SL_ArithUnderflow_Error #define SL_USAGE_ERROR SL_Usage_Error #define SL_INVALID_DATA_ERROR SL_Data_Error #define SL_UNICODE_ERROR SL_Unicode_Error #define SL_INVALID_UTF8 SL_InvalidUTF8_Error SL_EXTERN int SLang_Traceback; #define SL_TB_NONE 0x0 #define SL_TB_FULL 0x1 /* full traceback */ #define SL_TB_OMIT_LOCALS 0x2 /* full, but omit local vars */ #define SL_TB_PARTIAL 0x4 /* show just on line of traceback */ /* If non-zero, dump an S-Lang traceback upon error. Available as _traceback in S-Lang. */ SL_EXTERN char *SLang_User_Prompt; /* Prompt to use when reading from stdin */ SL_EXTERN int SLang_Version; SL_EXTERN SLFUTURE_CONST char *SLang_Version_String; SL_EXTERN SLFUTURE_CONST char *SLang_Doc_Dir; SL_EXTERN void (*SLang_VMessage_Hook) (SLFUTURE_CONST char *, va_list); SL_EXTERN void SLang_vmessage (SLFUTURE_CONST char *, ...) SLATTRIBUTE_PRINTF(1,2); SL_EXTERN void (*SLang_Error_Hook)(SLFUTURE_CONST char *); /* Pointer to application dependent error messaging routine. By default, messages are displayed on stderr. */ SL_EXTERN void (*SLang_Exit_Error_Hook)(SLFUTURE_CONST char *, va_list); SL_EXTERN void SLang_exit_error (SLFUTURE_CONST char *, ...) SLATTRIBUTE_((format (printf, 1, 2), noreturn)); SL_EXTERN void (*SLang_Dump_Routine)(SLFUTURE_CONST char *); /* Called if S-Lang traceback is enabled as well as other debugging routines (e.g., trace). By default, these messages go to stderr. */ SL_EXTERN void (*SLang_Interrupt)(void); /* function to call whenever inner interpreter is entered. This is a good place to set SLang_Error to USER_BREAK. */ SL_EXTERN void (*SLang_User_Clear_Error)(void); /* function that gets called when '_clear_error' is called. */ /* If non null, these call C functions before and after a slang function. */ SL_EXTERN void (*SLang_Enter_Function)(SLFUTURE_CONST char *); SL_EXTERN void (*SLang_Exit_Function)(SLFUTURE_CONST char *); SL_EXTERN int SLang_Num_Function_Args; /* This function should be called when a system call is interrupted. It * runs a set of hooks. If any of the hooks returns -1, then the system call * should not be restarted. */ SL_EXTERN int SLang_handle_interrupt (void); SL_EXTERN int SLang_add_interrupt_hook (int (*)(VOID_STAR), VOID_STAR); SL_EXTERN void SLang_remove_interrupt_hook (int (*)(VOID_STAR), VOID_STAR); /* Functions: */ SL_EXTERN int SLang_init_all (void); /* Initializes interpreter and all modules */ SL_EXTERN int SLang_init_slang (void); /* This function is mandatory and must be called by all applications that * use the interpreter */ SL_EXTERN int SLang_init_posix_process (void); /* process specific intrinsics */ SL_EXTERN int SLang_init_stdio (void); /* fgets, etc. stdio functions */ SL_EXTERN int SLang_init_posix_dir (void); SL_EXTERN int SLang_init_ospath (void); SL_EXTERN int SLang_init_slmath (void); /* called if math functions sin, cos, etc... are needed. */ /* These functions are obsolete. Use init_stdio, posix_process, etc. */ SL_EXTERN int SLang_init_slfile (void); SL_EXTERN int SLang_init_slunix (void); SL_EXTERN int SLang_init_slassoc (void); /* Assoc Arrays (Hashes) */ SL_EXTERN int SLang_init_array (void); /* Additional arrays functions: transpose, etc... */ SL_EXTERN int SLang_init_array_extra (void); /* Additional arrays functions, if any */ SL_EXTERN int SLang_init_signal (void); /* signal handling within the interpreter */ /* Dynamic linking facility */ SL_EXTERN int SLang_init_import (void); SL_EXTERN int SLang_load_file (SLFUTURE_CONST char *); /* Load a file of S-Lang code for interpreting. If the parameter is * NULL, input comes from stdin. */ SL_EXTERN void SLang_restart(int); /* should be called if an error occurs. If the passed integer is * non-zero, items are popped off the stack; otherwise, the stack is * left intact. Any time the stack is believed to be trashed, this routine * should be called with a non-zero argument (e.g., if setjmp/longjmp is * called). */ SL_EXTERN int SLang_byte_compile_file(SLFUTURE_CONST char *, int); /* takes a file of S-Lang code and ``byte-compiles'' it for faster * loading. The new filename is equivalent to the old except that a `c' is * appended to the name. (e.g., init.sl --> init.slc). The second * specified the method; currently, it is not used. */ SL_EXTERN int SLang_autoload(SLFUTURE_CONST char *, SLFUTURE_CONST char *); /* Automatically load S-Lang function p1 from file p2. This function is also available via S-Lang */ SL_EXTERN int SLang_load_string(SLFUTURE_CONST char *); /* Like SLang_load_file except input is from a null terminated string. */ SL_EXTERN int SLstack_depth(void); SL_EXTERN int SLdo_pop(void); SL_EXTERN int SLdo_pop_n(unsigned int); SL_EXTERN int SLang_push_char (char); SL_EXTERN int SLang_push_uchar (unsigned char); SL_EXTERN int SLang_pop_char (char *); SL_EXTERN int SLang_pop_uchar (unsigned char *); #define SLang_push_integer SLang_push_int #define SLang_push_uinteger SLang_push_uint #define SLang_pop_integer SLang_pop_int #define SLang_pop_uinteger SLang_pop_uint SL_EXTERN int SLang_push_int(int); SL_EXTERN int SLang_push_uint(unsigned int); SL_EXTERN int SLang_pop_int(int *); SL_EXTERN int SLang_pop_uint(unsigned int *); SL_EXTERN int SLang_pop_short(short *); SL_EXTERN int SLang_pop_ushort(unsigned short *); SL_EXTERN int SLang_push_short(short); SL_EXTERN int SLang_push_ushort(unsigned short); SL_EXTERN int SLang_pop_long(long *); SL_EXTERN int SLang_pop_ulong(unsigned long *); SL_EXTERN int SLang_push_long(long); SL_EXTERN int SLang_push_ulong(unsigned long); SL_EXTERN int SLang_pop_float(float *); SL_EXTERN int SLang_push_float(float); SL_EXTERN int SLang_pop_double(double *); SL_EXTERN int SLang_push_double(double); SL_EXTERN int SLang_push_complex (double, double); SL_EXTERN int SLang_pop_complex (double *, double *); SL_EXTERN int SLang_push_datatype (SLtype); SL_EXTERN int SLang_pop_datatype (SLtype *); SL_EXTERN int SLang_push_malloced_string(char *); /* The normal SLang_push_string pushes an slstring. This one converts * a normally malloced string to an slstring, and then frees the * malloced string. So, do NOT use the malloced string after calling * this routine because it will be freed! The routine returns -1 upon * error, but the string will be freed. */ SL_EXTERN int SLang_push_string(SLFUTURE_CONST char *); SL_EXTERN int SLpop_string (char **); /* malloced -- free with SLfree */ SL_EXTERN int SLang_push_null (void); SL_EXTERN int SLang_pop_null (void); SL_EXTERN int SLang_push_value (SLtype type, VOID_STAR); SL_EXTERN int SLang_pop_value (SLtype type, VOID_STAR); SL_EXTERN void SLang_free_value (SLtype type, VOID_STAR); typedef struct _pSLang_Object_Type SLang_Any_Type; SL_EXTERN int SLang_pop_anytype (SLang_Any_Type **); SL_EXTERN int SLang_push_anytype (SLang_Any_Type *); SL_EXTERN void SLang_free_anytype (SLang_Any_Type *); #ifdef SLANG_SOURCE_ typedef struct _pSLang_Ref_Type SLang_Ref_Type; #else typedef int SLang_Ref_Type; #endif SL_EXTERN int SLang_pop_ref (SLang_Ref_Type **); SL_EXTERN void SLang_free_ref (SLang_Ref_Type *); SL_EXTERN int SLang_assign_to_ref (SLang_Ref_Type *, SLtype, VOID_STAR); SL_EXTERN int SLang_assign_nametype_to_ref (SLang_Ref_Type *, SLang_Name_Type *); SL_EXTERN SLang_Name_Type *SLang_pop_function (void); SL_EXTERN int SLang_push_function (SLang_Name_Type *); SL_EXTERN SLang_Name_Type *SLang_get_fun_from_ref (SLang_Ref_Type *); SL_EXTERN void SLang_free_function (SLang_Name_Type *f); SL_EXTERN SLang_Name_Type *SLang_copy_function (SLang_Name_Type *); /* C structure interface */ SL_EXTERN int SLang_push_cstruct (VOID_STAR, SLang_CStruct_Field_Type *); SL_EXTERN int SLang_pop_cstruct (VOID_STAR, SLang_CStruct_Field_Type *); SL_EXTERN void SLang_free_cstruct (VOID_STAR, SLang_CStruct_Field_Type *); SL_EXTERN int SLang_assign_cstruct_to_ref (SLang_Ref_Type *, VOID_STAR, SLang_CStruct_Field_Type *); SL_EXTERN int SLang_is_defined(SLFUTURE_CONST char *); /* Return non-zero is p1 is defined otherwise returns 0. */ SL_EXTERN int SLang_run_hooks(SLFUTURE_CONST char *, unsigned int, ...); /* calls S-Lang function p1 pushing p2 strings in the variable argument * list onto the stack first. * Returns -1 upon error, 1 if hooks exists and it ran, * or 0 if hook does not exist. Thus it returns non-zero is hook was called. */ /* These functions return 1 if the indicated function exists and the function * runs without error. If the function does not exist, the function returns * 0. Otherwise -1 is returned with SLang_Error set appropriately. */ SL_EXTERN int SLexecute_function (SLang_Name_Type *); SL_EXTERN int SLang_execute_function(SLFUTURE_CONST char *); SL_EXTERN int SLang_end_arg_list (void); SL_EXTERN int SLang_start_arg_list (void); SL_EXTERN int SLang_add_intrinsic_array (SLFUTURE_CONST char *, /* name */ SLtype, /* type */ int, /* readonly */ VOID_STAR, /* data */ unsigned int, ...); /* num dims */ SL_EXTERN int SLextract_list_element (SLFUTURE_CONST char *, unsigned int, char, char *, unsigned int); /* If utf8_encode is >1, then byte values > 127 will be utf8-encoded. * If the string is already in utf8 form, and utf8 is desired, then use with * utf8_encode set to 0. A value of -1 implies use the value appropriate for * the current state of the interpreter. */ SL_EXTERN int SLexpand_escaped_string (char *dest, char *src, char *src_max, int utf8_encode); SL_EXTERN SLang_Name_Type *SLang_get_function (SLFUTURE_CONST char *); SL_EXTERN void SLang_release_function (SLang_Name_Type *); SL_EXTERN int SLreverse_stack (int); SL_EXTERN int SLroll_stack (int); /* If argument p is positive, the top p objects on the stack are rolled * up. If negative, the stack is rolled down. */ /* exchange two items on the stack. The top item is given by 0 */ SL_EXTERN int SLstack_exch (unsigned int, unsigned int); SL_EXTERN int SLdup_n (int n); /* Duplicate top n elements of stack */ SL_EXTERN int SLang_peek_at_stack1 (void); SL_EXTERN int SLang_peek_at_stack (void); SL_EXTERN int SLang_peek_at_stack_n (unsigned int n); SL_EXTERN int SLang_peek_at_stack1_n (unsigned int n); /* Returns type of next object on stack-- -1 upon stack underflow. */ SL_EXTERN void SLmake_lut (unsigned char *, unsigned char *, unsigned char); SL_EXTERN int SLang_guess_type (SLFUTURE_CONST char *); SL_EXTERN int SLstruct_create_struct (unsigned int, SLFUTURE_CONST char **, SLtype *, VOID_STAR *); /*}}}*/ /*{{{ Misc Functions */ /* This is an interface to atexit */ SL_EXTERN int SLang_add_cleanup_function (void (*)(void)); /* The SLmake_[n]string functions return malloced strings, and not slang hashed slstrings */ SL_EXTERN char *SLmake_string (SLFUTURE_CONST char *); SL_EXTERN char *SLmake_nstring (SLFUTURE_CONST char *, SLstrlen_Type); /* Returns a null terminated string made from the first n characters of the * string. */ /* Binary strings */ /* The binary string is an opaque type. Use the SLbstring_get_pointer function * to get a pointer and length. */ typedef struct _pSLang_BString_Type SLang_BString_Type; SL_EXTERN unsigned char *SLbstring_get_pointer (SLang_BString_Type *, SLstrlen_Type *); SL_EXTERN SLang_BString_Type *SLbstring_dup (SLang_BString_Type *); SL_EXTERN SLang_BString_Type *SLbstring_create (unsigned char *, SLstrlen_Type); /* The create_malloced function uses the first argument which is assumed * to be a pointer to a len + 1 malloced string. The extra byte is for * \0 termination. */ SL_EXTERN SLang_BString_Type *SLbstring_create_malloced (unsigned char *s, SLstrlen_Type len, int free_on_error); /* Create a bstring from an slstring */ SL_EXTERN SLang_BString_Type *SLbstring_create_slstring (SLFUTURE_CONST char *); SL_EXTERN void SLbstring_free (SLang_BString_Type *); SL_EXTERN int SLang_pop_bstring (SLang_BString_Type **); SL_EXTERN int SLang_push_bstring (SLang_BString_Type *); SL_EXTERN SLFUTURE_VOID *SLmalloc (SLstrlen_Type); SL_EXTERN SLFUTURE_VOID *SLcalloc (SLstrlen_Type, SLstrlen_Type); SL_EXTERN void SLfree(SLFUTURE_VOID *); /* This function handles NULL */ SL_EXTERN SLFUTURE_VOID *SLrealloc (SLFUTURE_VOID *, SLstrlen_Type); SL_EXTERN char *SLcurrent_time_string (void); SL_EXTERN int SLatoi(unsigned char *); SL_EXTERN long SLatol (unsigned char *); SL_EXTERN unsigned long SLatoul (unsigned char *); #ifdef HAVE_LONG_LONG SL_EXTERN long long SLatoll (unsigned char *s); SL_EXTERN unsigned long long SLatoull (unsigned char *s); #endif SL_EXTERN int SLang_pop_fileptr (SLang_MMT_Type **, FILE **); SL_EXTERN SLFUTURE_CONST char *SLang_get_name_from_fileptr (SLang_MMT_Type *); SL_EXTERN int SLang_get_fileptr (SLang_MMT_Type *, FILE **); /* This function may be used to obtain the FILE* object associated with an MMT. * It returns 0 if no-errors were encountered, and -1 otherwise. * If FILE* object has been closed, this function will return 0 and set the FILE* * parameter to NULL. */ typedef struct _pSLFile_FD_Type SLFile_FD_Type; SL_EXTERN SLFile_FD_Type *SLfile_create_fd (SLFUTURE_CONST char *, int); SL_EXTERN void SLfile_free_fd (SLFile_FD_Type *); SL_EXTERN int SLfile_push_fd (SLFile_FD_Type *); SL_EXTERN int SLfile_pop_fd (SLFile_FD_Type **); SL_EXTERN int SLfile_get_fd (SLFile_FD_Type *, int *); SL_EXTERN SLFile_FD_Type *SLfile_dup_fd (SLFile_FD_Type *f0); SL_EXTERN int SLang_init_posix_io (void); /* These routines allow an application to attach an object to a file-descriptor * as well a provide read/write/close/etc methods. To allow the coexistence of * different types of objects, a clientdata-id must be used. */ SL_EXTERN int SLfile_set_getfd_method (SLFile_FD_Type *f, int (*func)(VOID_STAR, int *)); SL_EXTERN int SLfile_set_close_method (SLFile_FD_Type *f, int (*func)(VOID_STAR)); SL_EXTERN int SLfile_set_read_method (SLFile_FD_Type *f, int (*func)(VOID_STAR, char*, unsigned int)); SL_EXTERN int SLfile_set_write_method (SLFile_FD_Type *f, int (*func)(VOID_STAR, char*, unsigned int)); SL_EXTERN int SLfile_set_dup_method (SLFile_FD_Type *f, SLFile_FD_Type *(*func)(VOID_STAR)); SL_EXTERN int SLfile_create_clientdata_id (int *id); SL_EXTERN int SLfile_set_clientdata (SLFile_FD_Type *f, void (*free_func)(VOID_STAR), VOID_STAR cd, int id); SL_EXTERN int SLfile_get_clientdata (SLFile_FD_Type *f, int id, VOID_STAR *cdp); typedef double (*SLang_To_Double_Fun_Type)(VOID_STAR); SL_EXTERN SLang_To_Double_Fun_Type SLarith_get_to_double_fun (SLtype, unsigned int *); SL_EXTERN int SLang_set_argc_argv (int, char **); /*}}}*/ /*{{{ Qualifier Functions */ SL_EXTERN int SLang_qualifier_exists (SLCONST char *name); SL_EXTERN int SLang_get_int_qualifier (SLCONST char *name, int *val, int defval); SL_EXTERN int SLang_get_long_qualifier (SLCONST char *name, long *val, long defval); SL_EXTERN int SLang_get_double_qualifier (SLCONST char *name, double *val, double defval); SL_EXTERN int SLang_get_string_qualifier (SLCONST char *name, char **val, SLFUTURE_CONST char *defval); /*}}}*/ /*{{{ SLang getkey interface Functions */ #ifdef REAL_UNIX_SYSTEM SL_EXTERN int SLang_TT_Baud_Rate; SL_EXTERN int SLang_TT_Read_FD; #else # if defined(__WIN32__) /* I do not want to include windows.h just to get the typedef for HANDLE. * Make this conditional upon the inclusion of windows.h. */ # ifdef _WINDOWS_ SL_EXTERN HANDLE SLw32_Hstdin; # endif # endif #endif SL_EXTERN int SLang_init_tty (int, int, int); /* Initializes the tty for single character input. If the first parameter *p1 * is in the range 0-255, it will be used for the abort character; * otherwise, (unix only) if it is -1, the abort character will be the one * used by the terminal. If the second parameter p2 is non-zero, flow * control is enabled. If the last parmeter p3 is zero, output processing * is NOT turned on. A value of zero is required for the screen management * routines. Returns 0 upon success. In addition, if SLang_TT_Baud_Rate == * 0 when this function is called, SLang will attempt to determine the * terminals baud rate. As far as the SLang library is concerned, if * SLang_TT_Baud_Rate is less than or equal to zero, the baud rate is * effectively infinite. */ SL_EXTERN void SLang_reset_tty (void); /* Resets tty to what it was prior to a call to SLang_init_tty */ #ifdef REAL_UNIX_SYSTEM SL_EXTERN void SLtty_set_suspend_state (int); /* If non-zero argument, terminal driver will be told to react to the * suspend character. If 0, it will not. */ SL_EXTERN int (*SLang_getkey_intr_hook) (void); #endif #define SLANG_GETKEY_ERROR 0xFFFF SL_EXTERN unsigned int SLang_getkey (void); /* reads a single key from the tty. If the read fails, 0xFFFF is returned. */ #ifdef IBMPC_SYSTEM SL_EXTERN int SLgetkey_map_to_ansi (int); #endif SL_EXTERN int SLang_ungetkey_string (unsigned char *, unsigned int); SL_EXTERN int SLang_buffer_keystring (unsigned char *, unsigned int); SL_EXTERN int SLang_ungetkey (unsigned char); SL_EXTERN void SLang_flush_input (void); SL_EXTERN int SLang_input_pending (int); SL_EXTERN int SLang_Abort_Char; /* The value of the character (0-255) used to trigger SIGINT */ SL_EXTERN int SLang_Ignore_User_Abort; /* If non-zero, pressing the abort character will not result in USER_BREAK * SLang_Error. */ SL_EXTERN int SLang_set_abort_signal (void (*)(int)); /* If SIGINT is generated, the function p1 will be called. If p1 is NULL * the SLang_default signal handler is called. This sets SLang_Error to * USER_BREAK. I suspect most users will simply want to pass NULL. */ SL_EXTERN unsigned int SLang_Input_Buffer_Len; SL_EXTERN volatile int SLKeyBoard_Quit; #ifdef VMS /* If this function returns -1, ^Y will be added to input buffer. */ SL_EXTERN int (*SLtty_VMS_Ctrl_Y_Hook) (void); #endif /*}}}*/ /*{{{ SLang Keymap routines */ typedef struct SLKeymap_Function_Type { SLFUTURE_CONST char *name; FVOID_STAR f; } SLKeymap_Function_Type; #define SLANG_MAX_KEYMAP_KEY_SEQ 14 typedef struct SLang_Key_Type { struct SLang_Key_Type *next; union { char *s; FVOID_STAR f; unsigned int keysym; SLang_Name_Type *slang_fun; } f; unsigned char type; /* type of function */ #define SLKEY_F_INTERPRET 0x01 #define SLKEY_F_INTRINSIC 0x02 #define SLKEY_F_KEYSYM 0x03 #define SLKEY_F_SLANG 0x04 unsigned char str[SLANG_MAX_KEYMAP_KEY_SEQ + 1];/* key sequence */ } SLang_Key_Type; int SLkm_set_free_method (int, void (*)(int, VOID_STAR)); typedef struct _pSLkeymap_Type { SLFUTURE_CONST char *name; /* hashed string */ SLang_Key_Type *keymap; SLKeymap_Function_Type *functions; /* intrinsic functions */ struct _pSLkeymap_Type *next; } SLkeymap_Type; SL_EXTERN SLkeymap_Type *SLKeyMap_List_Root; /* linked list of keymaps */ /* backward compat */ typedef SLkeymap_Type SLKeyMap_List_Type; SL_EXTERN char *SLang_process_keystring(SLFUTURE_CONST char *); SL_EXTERN int SLkm_define_key (SLFUTURE_CONST char *, FVOID_STAR, SLkeymap_Type *); SL_EXTERN int SLang_define_key(SLFUTURE_CONST char *, SLFUTURE_CONST char *, SLkeymap_Type *); /* Like define_key1 except that p2 is a string that is to be associated with * a function in the functions field of p3. */ SL_EXTERN int SLkm_define_keysym (SLFUTURE_CONST char *, unsigned int, SLkeymap_Type *); SL_EXTERN int SLkm_define_slkey (SLFUTURE_CONST char *keysequence, SLang_Name_Type *func, SLkeymap_Type *); SL_EXTERN void SLang_undefine_key(SLFUTURE_CONST char *, SLkeymap_Type *); SL_EXTERN SLkeymap_Type *SLang_create_keymap(SLFUTURE_CONST char *, SLkeymap_Type *); /* create and returns a pointer to a new keymap named p1 created by copying * keymap p2. If p2 is NULL, it is up to the calling routine to initialize * the keymap. */ SL_EXTERN char *SLang_make_keystring(unsigned char *); SL_EXTERN SLang_Key_Type *SLang_do_key(SLkeymap_Type *, int (*)(void)); /* read a key using keymap p1 with getkey function p2 */ SL_EXTERN FVOID_STAR SLang_find_key_function(SLFUTURE_CONST char *, SLkeymap_Type *); SL_EXTERN SLkeymap_Type *SLang_find_keymap(SLFUTURE_CONST char *); SL_EXTERN int SLang_Last_Key_Char; /* Despite the name of this variable, its value is the last BYTE of a key-sequence */ SL_EXTERN int SLang_Key_TimeOut_Flag; /*}}}*/ /*{{{ SLang Readline Interface */ typedef struct _pSLrline_Type SLrline_Type; SL_EXTERN SLrline_Type *SLrline_open (unsigned int width, unsigned int flags); SL_EXTERN SLrline_Type *SLrline_open2 (SLFUTURE_CONST char *, unsigned int width, unsigned int flags); #define SL_RLINE_NO_ECHO 0x0001 #define SL_RLINE_USE_ANSI 0x0002 #define SL_RLINE_BLINK_MATCH 0x0004 #define SL_RLINE_UTF8_MODE 0x0008 #define SL_RLINE_USE_MULTILINE 0x0010 SL_EXTERN void SLrline_close (SLrline_Type *); /* This returns a malloced string */ SL_EXTERN char *SLrline_read_line (SLrline_Type *, SLFUTURE_CONST char *prompt, unsigned int *lenp); SL_EXTERN int SLrline_bol (SLrline_Type *); SL_EXTERN int SLrline_eol (SLrline_Type *); SL_EXTERN int SLrline_del (SLrline_Type *, unsigned int len); SL_EXTERN int SLrline_ins (SLrline_Type *, SLFUTURE_CONST char *s, unsigned int len); SL_EXTERN int SLrline_move (SLrline_Type *, int); SL_EXTERN int SLrline_set_echo (SLrline_Type *, int); SL_EXTERN int SLrline_set_tab (SLrline_Type *, unsigned int tabwidth); SL_EXTERN int SLrline_set_point (SLrline_Type *, unsigned int); SL_EXTERN int SLrline_set_line (SLrline_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLrline_set_hscroll (SLrline_Type *, unsigned int); SL_EXTERN int SLrline_set_display_width (SLrline_Type *, unsigned int); SL_EXTERN int SLrline_get_echo (SLrline_Type *, int *); SL_EXTERN int SLrline_get_tab (SLrline_Type *, unsigned int *); SL_EXTERN int SLrline_get_point (SLrline_Type *, unsigned int *); SL_EXTERN char *SLrline_get_line (SLrline_Type *); SL_EXTERN int SLrline_get_hscroll (SLrline_Type *, unsigned int *); SL_EXTERN int SLrline_get_display_width (SLrline_Type *, unsigned int *); SL_EXTERN int SLrline_set_update_hook (SLrline_Type *, void (*)(SLrline_Type *rli, SLFUTURE_CONST char *prompt, SLFUTURE_CONST char *buf, unsigned int len, unsigned int point, VOID_STAR client_data), VOID_STAR client_data); /* free update_hook client_data */ SL_EXTERN void SLrline_set_free_update_cb (SLrline_Type *, void (*)(SLrline_Type *, VOID_STAR)); /* These functions are passed a pointer to the update_hook client_data */ SL_EXTERN void SLrline_set_update_clear_cb(SLrline_Type *, void (*)(SLrline_Type *, VOID_STAR)); SL_EXTERN void SLrline_set_update_preread_cb (SLrline_Type *, void (*)(SLrline_Type *, VOID_STAR)); SL_EXTERN void SLrline_set_update_postread_cb (SLrline_Type *, void (*)(SLrline_Type *, VOID_STAR)); SL_EXTERN void SLrline_set_update_width_cb (SLrline_Type *, void (*)(SLrline_Type *, int, VOID_STAR)); SL_EXTERN int SLrline_get_update_client_data (SLrline_Type *, VOID_STAR *); SL_EXTERN SLkeymap_Type *SLrline_get_keymap (SLrline_Type *); SL_EXTERN void SLrline_redraw (SLrline_Type *); SL_EXTERN int SLrline_save_line (SLrline_Type *); SL_EXTERN int SLrline_add_to_history (SLrline_Type *, SLFUTURE_CONST char *); /* Interpreter interface */ SL_EXTERN int SLrline_init (SLFUTURE_CONST char *appname, SLFUTURE_CONST char *user_initfile, SLFUTURE_CONST char *sys_initfile); /* Compatibility */ typedef SLrline_Type SLang_RLine_Info_Type; /*}}}*/ /*{{{ Low Level Screen Output Interface */ SL_EXTERN unsigned long SLtt_Num_Chars_Output; SL_EXTERN int SLtt_Baud_Rate; typedef unsigned long SLtt_Char_Type; #define SLTT_BOLD_MASK 0x01000000UL #define SLTT_BLINK_MASK 0x02000000UL #define SLTT_ULINE_MASK 0x04000000UL #define SLTT_REV_MASK 0x08000000UL #define SLTT_ALTC_MASK 0x10000000UL #define SLTT_ITALIC_MASK 0x20000000UL SL_EXTERN int SLtt_Screen_Rows; SL_EXTERN int SLtt_Screen_Cols; SL_EXTERN int SLtt_Term_Cannot_Insert; SL_EXTERN int SLtt_Term_Cannot_Scroll; SL_EXTERN int SLtt_Use_Ansi_Colors; SL_EXTERN int SLtt_Ignore_Beep; #if defined(REAL_UNIX_SYSTEM) SL_EXTERN int SLtt_Force_Keypad_Init; SL_EXTERN int SLang_TT_Write_FD; #endif #ifndef IBMPC_SYSTEM SL_EXTERN char *SLtt_Graphics_Char_Pairs; #endif #ifndef __GO32__ #if defined(VMS) || defined(REAL_UNIX_SYSTEM) SL_EXTERN int SLtt_Blink_Mode; SL_EXTERN int SLtt_Use_Blink_For_ACS; SL_EXTERN int SLtt_Newline_Ok; SL_EXTERN int SLtt_Has_Alt_Charset; SL_EXTERN int SLtt_Has_Status_Line; /* if 0, NO. If > 0, YES, IF -1, ?? */ # ifndef VMS SL_EXTERN int SLtt_Try_Termcap; # endif #endif #endif #if defined(IBMPC_SYSTEM) SL_EXTERN int SLtt_Msdos_Cheap_Video; #endif typedef unsigned short SLsmg_Color_Type; #define SLSMG_MAX_COLORS 0x7FFE /* keep one for BCE */ #define SLSMG_COLOR_MASK 0x7FFF #define SLSMG_ACS_MASK 0x8000 #define SLSMG_MAX_CHARS_PER_CELL 5 typedef struct { unsigned int nchars; SLwchar_Type wchars[SLSMG_MAX_CHARS_PER_CELL]; SLsmg_Color_Type color; } SLsmg_Char_Type; #define SLSMG_EXTRACT_COLOR(x) ((x).color) #define SLSMG_EXTRACT_CHAR(x) ((x).wchars[0]) SL_EXTERN int SLtt_flush_output (void); SL_EXTERN void SLtt_set_scroll_region(int, int); SL_EXTERN void SLtt_reset_scroll_region(void); SL_EXTERN void SLtt_reverse_video (int); SL_EXTERN void SLtt_bold_video (void); SL_EXTERN void SLtt_begin_insert(void); SL_EXTERN void SLtt_end_insert(void); SL_EXTERN void SLtt_del_eol(void); SL_EXTERN void SLtt_goto_rc (int, int); SL_EXTERN void SLtt_delete_nlines(int); SL_EXTERN void SLtt_delete_char(void); SL_EXTERN void SLtt_erase_line(void); SL_EXTERN void SLtt_normal_video(void); SL_EXTERN void SLtt_cls(void); SL_EXTERN void SLtt_beep(void); SL_EXTERN void SLtt_reverse_index(int); SL_EXTERN void SLtt_smart_puts(SLsmg_Char_Type *, SLsmg_Char_Type *, int, int); SL_EXTERN void SLtt_write_string (SLFUTURE_CONST char *); SL_EXTERN void SLtt_putchar(char); SL_EXTERN int SLtt_init_video (void); SL_EXTERN int SLtt_reset_video (void); SL_EXTERN void SLtt_get_terminfo(void); SL_EXTERN void SLtt_get_screen_size (void); SL_EXTERN int SLtt_set_cursor_visibility (int); SL_EXTERN int SLtt_set_mouse_mode (int, int); #if defined(VMS) || defined(REAL_UNIX_SYSTEM) SL_EXTERN int SLtt_initialize (SLFUTURE_CONST char *); SL_EXTERN void SLtt_enable_cursor_keys(void); SL_EXTERN void SLtt_set_term_vtxxx(int *); SL_EXTERN void SLtt_wide_width(void); SL_EXTERN void SLtt_narrow_width(void); SL_EXTERN void SLtt_set_alt_char_set (int); SL_EXTERN int SLtt_write_to_status_line (SLFUTURE_CONST char *, int); SL_EXTERN void SLtt_disable_status_line (void); # ifdef REAL_UNIX_SYSTEM /* These are termcap/terminfo routines that assume SLtt_initialize has * been called. */ SL_EXTERN char *SLtt_tgetstr (SLFUTURE_CONST char *); SL_EXTERN int SLtt_tgetnum (SLFUTURE_CONST char *); SL_EXTERN int SLtt_tgetflag (SLFUTURE_CONST char *); SL_EXTERN int SLtt_tgetent(char *name); SL_EXTERN char *SLtt_tgoto(char *cap, int col, int row); SL_EXTERN int SLtt_tputs(char *str, int affcnt, int (*putcfun)(int)); /* The following are terminfo-only routines -- these prototypes will change * in V2.x. */ SL_EXTERN char *SLtt_tigetent (SLFUTURE_CONST char *); SL_EXTERN char *SLtt_tigetstr (SLFUTURE_CONST char *, char **); SL_EXTERN int SLtt_tigetnum (SLFUTURE_CONST char *, char **); # endif #endif SL_EXTERN SLtt_Char_Type SLtt_get_color_object (int); SL_EXTERN int SLtt_set_color_object (int, SLtt_Char_Type); SL_EXTERN int SLtt_set_color (int, SLFUTURE_CONST char *, SLFUTURE_CONST char *, SLFUTURE_CONST char *); SL_EXTERN int SLtt_set_mono (int, SLFUTURE_CONST char *, SLtt_Char_Type); SL_EXTERN int SLtt_add_color_attribute (int, SLtt_Char_Type); SL_EXTERN int SLtt_set_color_fgbg (int, SLtt_Char_Type, SLtt_Char_Type); /*}}}*/ /*{{{ SLang Preprocessor Interface */ /* #define SLPreprocess_Type SLprep_Type; */ typedef struct _pSLprep_Type SLprep_Type; SL_EXTERN SLprep_Type *SLprep_new (void); SL_EXTERN void SLprep_delete (SLprep_Type *); SL_EXTERN int SLprep_line_ok (SLFUTURE_CONST char *, SLprep_Type *); SL_EXTERN int SLprep_set_flags (SLprep_Type *, unsigned int flags); #define SLPREP_BLANK_LINES_OK 0x1 #define SLPREP_COMMENT_LINES_OK 0x2 SL_EXTERN int SLprep_set_comment (SLprep_Type *, SLFUTURE_CONST char *, SLFUTURE_CONST char *); SL_EXTERN int SLprep_set_prefix (SLprep_Type *, SLFUTURE_CONST char *); SL_EXTERN int SLprep_set_exists_hook (SLprep_Type *, int (*)(SLprep_Type *, SLFUTURE_CONST char *)); SL_EXTERN int SLprep_set_eval_hook (SLprep_Type *, int (*)(SLprep_Type *, SLFUTURE_CONST char *)); SL_EXTERN int SLdefine_for_ifdef (SLFUTURE_CONST char *); /* Adds a string to the SLang #ifdef preparsing defines. SLang already defines MSDOS, UNIX, and VMS on the appropriate system. */ /*}}}*/ /*{{{ SLsmg Screen Management Functions */ SL_EXTERN void SLsmg_fill_region (int, int, unsigned int, unsigned int, SLwchar_Type); SL_EXTERN void SLsmg_set_char_set (int); #ifndef IBMPC_SYSTEM SL_EXTERN int SLsmg_Scroll_Hash_Border; #endif SL_EXTERN int SLsmg_suspend_smg (void); SL_EXTERN int SLsmg_resume_smg (void); SL_EXTERN void SLsmg_erase_eol (void); SL_EXTERN void SLsmg_gotorc (int, int); SL_EXTERN void SLsmg_erase_eos (void); SL_EXTERN void SLsmg_reverse_video (void); SL_EXTERN void SLsmg_set_color (SLsmg_Color_Type); SL_EXTERN void SLsmg_normal_video (void); SL_EXTERN void SLsmg_printf (SLFUTURE_CONST char *, ...) SLATTRIBUTE_PRINTF(1,2); /* SL_EXTERN void SLsmg_printf (SLFUTURE_CONST char *, ...) SLATTRIBUTE_PRINTF(1,2); */ SL_EXTERN void SLsmg_vprintf (SLFUTURE_CONST char *, va_list); SL_EXTERN void SLsmg_write_string (SLFUTURE_CONST char *); SL_EXTERN void SLsmg_write_nstring (SLFUTURE_CONST char *, unsigned int); SL_EXTERN void SLsmg_write_chars (SLuchar_Type *u, SLuchar_Type *umax); SL_EXTERN void SLsmg_write_nchars (SLFUTURE_CONST char *str, unsigned int len); SL_EXTERN void SLsmg_write_char (SLwchar_Type ch); SL_EXTERN void SLsmg_write_wrapped_string (SLuchar_Type *, int, int, unsigned int, unsigned int, int); SL_EXTERN void SLsmg_cls (void); SL_EXTERN void SLsmg_refresh (void); SL_EXTERN void SLsmg_touch_lines (int, unsigned int); SL_EXTERN void SLsmg_touch_screen (void); SL_EXTERN int SLsmg_init_smg (void); SL_EXTERN int SLsmg_reinit_smg (void); SL_EXTERN void SLsmg_reset_smg (void); SL_EXTERN int SLsmg_char_at (SLsmg_Char_Type *); SL_EXTERN void SLsmg_set_screen_start (int *, int *); SL_EXTERN void SLsmg_draw_hline (unsigned int); SL_EXTERN void SLsmg_draw_vline (int); SL_EXTERN void SLsmg_draw_object (int, int, SLwchar_Type); SL_EXTERN void SLsmg_draw_box (int, int, unsigned int, unsigned int); SL_EXTERN int SLsmg_get_column(void); SL_EXTERN int SLsmg_get_row(void); SL_EXTERN void SLsmg_forward (int); SL_EXTERN void SLsmg_write_color_chars (SLsmg_Char_Type *, unsigned int); SL_EXTERN unsigned int SLsmg_read_raw (SLsmg_Char_Type *, unsigned int); SL_EXTERN unsigned int SLsmg_write_raw (SLsmg_Char_Type *, unsigned int); SL_EXTERN void SLsmg_set_color_in_region (int, int, int, unsigned int, unsigned int); SL_EXTERN unsigned int SLsmg_strwidth (SLuchar_Type *u, SLuchar_Type *max); SL_EXTERN unsigned int SLsmg_strbytes (SLuchar_Type *u, SLuchar_Type *max, unsigned int width); SL_EXTERN int SLsmg_embedded_escape_mode (int on_or_off); SL_EXTERN int SLsmg_Display_Eight_Bit; SL_EXTERN int SLsmg_Tab_Width; #define SLSMG_NEWLINE_IGNORED 0 /* default */ #define SLSMG_NEWLINE_MOVES 1 /* moves to next line, column 0 */ #define SLSMG_NEWLINE_SCROLLS 2 /* moves but scrolls at bottom of screen */ #define SLSMG_NEWLINE_PRINTABLE 3 /* prints as ^J */ SL_EXTERN int SLsmg_Newline_Behavior; SL_EXTERN int SLsmg_Backspace_Moves; #ifdef IBMPC_SYSTEM # define SLSMG_HLINE_CHAR 0xC4 # define SLSMG_VLINE_CHAR 0xB3 # define SLSMG_ULCORN_CHAR 0xDA # define SLSMG_URCORN_CHAR 0xBF # define SLSMG_LLCORN_CHAR 0xC0 # define SLSMG_LRCORN_CHAR 0xD9 # define SLSMG_RTEE_CHAR 0xB4 # define SLSMG_LTEE_CHAR 0xC3 # define SLSMG_UTEE_CHAR 0xC2 # define SLSMG_DTEE_CHAR 0xC1 # define SLSMG_PLUS_CHAR 0xC5 /* There are several to choose from: 0xB0, 0xB1, and 0xB2 */ # define SLSMG_CKBRD_CHAR 0xB0 # define SLSMG_DIAMOND_CHAR 0x04 # define SLSMG_DEGREE_CHAR 0xF8 # define SLSMG_PLMINUS_CHAR 0xF1 # define SLSMG_BULLET_CHAR 0xF9 # define SLSMG_LARROW_CHAR 0x1B # define SLSMG_RARROW_CHAR 0x1A # define SLSMG_DARROW_CHAR 0x19 # define SLSMG_UARROW_CHAR 0x18 # define SLSMG_BOARD_CHAR 0xB2 # define SLSMG_BLOCK_CHAR 0xDB #else # if defined(AMIGA) # define SLSMG_HLINE_CHAR ((unsigned char)'-') # define SLSMG_VLINE_CHAR ((unsigned char)'|') # define SLSMG_ULCORN_CHAR ((unsigned char)'+') # define SLSMG_URCORN_CHAR ((unsigned char)'+') # define SLSMG_LLCORN_CHAR ((unsigned char)'+') # define SLSMG_LRCORN_CHAR ((unsigned char)'+') # define SLSMG_CKBRD_CHAR ((unsigned char)'#') # define SLSMG_RTEE_CHAR ((unsigned char)'+') # define SLSMG_LTEE_CHAR ((unsigned char)'+') # define SLSMG_UTEE_CHAR ((unsigned char)'+') # define SLSMG_DTEE_CHAR ((unsigned char)'+') # define SLSMG_PLUS_CHAR ((unsigned char)'+') # define SLSMG_DIAMOND_CHAR ((unsigned char)'+') # define SLSMG_DEGREE_CHAR ((unsigned char)'\\') # define SLSMG_PLMINUS_CHAR ((unsigned char)'#') # define SLSMG_BULLET_CHAR ((unsigned char)'o') # define SLSMG_LARROW_CHAR ((unsigned char)'<') # define SLSMG_RARROW_CHAR ((unsigned char)'>') # define SLSMG_DARROW_CHAR ((unsigned char)'v') # define SLSMG_UARROW_CHAR ((unsigned char)'^') # define SLSMG_BOARD_CHAR ((unsigned char)'#') # define SLSMG_BLOCK_CHAR ((unsigned char)'#') # else # define SLSMG_HLINE_CHAR ((unsigned char)'q') # define SLSMG_VLINE_CHAR ((unsigned char)'x') # define SLSMG_ULCORN_CHAR ((unsigned char)'l') # define SLSMG_URCORN_CHAR ((unsigned char)'k') # define SLSMG_LLCORN_CHAR ((unsigned char)'m') # define SLSMG_LRCORN_CHAR ((unsigned char)'j') # define SLSMG_CKBRD_CHAR ((unsigned char)'a') # define SLSMG_RTEE_CHAR ((unsigned char)'u') # define SLSMG_LTEE_CHAR ((unsigned char)'t') # define SLSMG_UTEE_CHAR ((unsigned char)'w') # define SLSMG_DTEE_CHAR ((unsigned char)'v') # define SLSMG_PLUS_CHAR ((unsigned char)'n') # define SLSMG_DIAMOND_CHAR ((unsigned char)'`') # define SLSMG_DEGREE_CHAR ((unsigned char)'f') # define SLSMG_PLMINUS_CHAR ((unsigned char)'g') # define SLSMG_BULLET_CHAR ((unsigned char)'~') # define SLSMG_LARROW_CHAR ((unsigned char)',') # define SLSMG_RARROW_CHAR ((unsigned char)'+') # define SLSMG_DARROW_CHAR ((unsigned char)'.') # define SLSMG_UARROW_CHAR ((unsigned char)'-') # define SLSMG_BOARD_CHAR ((unsigned char)'h') # define SLSMG_BLOCK_CHAR ((unsigned char)'0') # endif /* AMIGA */ #endif /* IBMPC_SYSTEM */ #ifndef IBMPC_SYSTEM # define SLSMG_COLOR_BLACK 0x000000 # define SLSMG_COLOR_RED 0x000001 # define SLSMG_COLOR_GREEN 0x000002 # define SLSMG_COLOR_BROWN 0x000003 # define SLSMG_COLOR_BLUE 0x000004 # define SLSMG_COLOR_MAGENTA 0x000005 # define SLSMG_COLOR_CYAN 0x000006 # define SLSMG_COLOR_LGRAY 0x000007 # define SLSMG_COLOR_GRAY 0x000008 # define SLSMG_COLOR_BRIGHT_RED 0x000009 # define SLSMG_COLOR_BRIGHT_GREEN 0x00000A # define SLSMG_COLOR_BRIGHT_BROWN 0x00000B # define SLSMG_COLOR_BRIGHT_BLUE 0x00000C # define SLSMG_COLOR_BRIGHT_MAGENTA 0x00000D # define SLSMG_COLOR_BRIGHT_CYAN 0x00000E # define SLSMG_COLOR_BRIGHT_WHITE 0x00000F #endif typedef struct { void (*tt_normal_video)(void); void (*tt_set_scroll_region)(int, int); void (*tt_goto_rc)(int, int); void (*tt_reverse_index)(int); void (*tt_reset_scroll_region)(void); void (*tt_delete_nlines)(int); void (*tt_cls) (void); void (*tt_del_eol) (void); void (*tt_smart_puts) (SLsmg_Char_Type *, SLsmg_Char_Type *, int, int); int (*tt_flush_output) (void); int (*tt_reset_video) (void); int (*tt_init_video) (void); int *tt_screen_rows; int *tt_screen_cols; int *tt_term_cannot_scroll; #if 0 int *tt_use_blink_for_acs; #endif int *tt_has_alt_charset; char **tt_graphic_char_pairs; int *unicode_ok; long reserved[4]; } SLsmg_Term_Type; SL_EXTERN void SLsmg_set_terminal_info (SLsmg_Term_Type *); /*}}}*/ /*{{{ SLang Keypad Interface */ #define SL_KEY_ERR 0xFFFF #define SL_KEY_UP 0x101 #define SL_KEY_DOWN 0x102 #define SL_KEY_LEFT 0x103 #define SL_KEY_RIGHT 0x104 #define SL_KEY_PPAGE 0x105 #define SL_KEY_NPAGE 0x106 #define SL_KEY_HOME 0x107 #define SL_KEY_END 0x108 #define SL_KEY_A1 0x109 #define SL_KEY_A3 0x10A #define SL_KEY_B2 0x10B #define SL_KEY_C1 0x10C #define SL_KEY_C3 0x10D #define SL_KEY_REDO 0x10E #define SL_KEY_UNDO 0x10F #define SL_KEY_BACKSPACE 0x110 #define SL_KEY_ENTER 0x111 #define SL_KEY_IC 0x112 #define SL_KEY_DELETE 0x113 #define SL_KEY_F0 0x200 #define SL_KEY_F(X) (SL_KEY_F0 + X) /* I do not intend to use keysymps > 0x1000. Applications can use those. */ /* Returns 0 upon success or -1 upon error. */ SL_EXTERN int SLkp_define_keysym (SLFUTURE_CONST char *, unsigned int); /* This function must be called AFTER SLtt_get_terminfo and not before. */ SL_EXTERN int SLkp_init (void); /* By default, SLang_getkey is used as the low-level function. This hook * allows you to specify something else. */ SL_EXTERN void SLkp_set_getkey_function (int (*)(void)); /* This function uses SLang_getkey and assumes that what ever initialization * is required for SLang_getkey has been performed. If you do not want * SLang_getkey to be used, then specify another function via * SLkp_set_getkey_function. */ SL_EXTERN int SLkp_getkey (void); /*}}}*/ /*{{{ SLang Scroll Interface */ typedef struct _pSLscroll_Type { struct _pSLscroll_Type *next; struct _pSLscroll_Type *prev; unsigned int flags; } SLscroll_Type; typedef struct { unsigned int flags; SLscroll_Type *top_window_line; /* list element at top of window */ SLscroll_Type *bot_window_line; /* list element at bottom of window */ SLscroll_Type *current_line; /* current list element */ SLscroll_Type *lines; /* first list element */ unsigned int nrows; /* number of rows in window */ unsigned int hidden_mask; /* applied to flags in SLscroll_Type */ unsigned int line_num; /* current line number (visible) */ unsigned int num_lines; /* total number of lines (visible) */ unsigned int window_row; /* row of current_line in window */ unsigned int border; /* number of rows that form scroll border */ int cannot_scroll; /* should window scroll or recenter */ } SLscroll_Window_Type; SL_EXTERN int SLscroll_find_top (SLscroll_Window_Type *); SL_EXTERN int SLscroll_find_line_num (SLscroll_Window_Type *); SL_EXTERN unsigned int SLscroll_next_n (SLscroll_Window_Type *, unsigned int); SL_EXTERN unsigned int SLscroll_prev_n (SLscroll_Window_Type *, unsigned int); SL_EXTERN int SLscroll_pageup (SLscroll_Window_Type *); SL_EXTERN int SLscroll_pagedown (SLscroll_Window_Type *); /*}}}*/ /*{{{ Signal Routines */ typedef void SLSig_Fun_Type (int); SL_EXTERN SLSig_Fun_Type *SLsignal (int, SLSig_Fun_Type *); SL_EXTERN SLSig_Fun_Type *SLsignal_intr (int, SLSig_Fun_Type *); SL_EXTERN int SLsig_block_signals (void); SL_EXTERN int SLsig_unblock_signals (void); SL_EXTERN int SLsystem (SLFUTURE_CONST char *); SL_EXTERN int SLsystem_intr (SLFUTURE_CONST char *); /* Make a signal off-limits to the interpreter */ SL_EXTERN int SLsig_forbid_signal (int); SL_EXTERN SLFUTURE_CONST char *SLerrno_strerror (int); SL_EXTERN int SLerrno_set_errno (int); /*}}}*/ /* Functions for dealing with the FPU */ SL_EXTERN void SLfpu_clear_except_bits (void); SL_EXTERN unsigned int SLfpu_test_except_bits (unsigned int bits); #define SL_FE_DIVBYZERO 0x01 #define SL_FE_INVALID 0x02 #define SL_FE_OVERFLOW 0x04 #define SL_FE_UNDERFLOW 0x08 #define SL_FE_INEXACT 0x10 #define SL_FE_ALLEXCEPT 0x1F SL_EXTERN SLtype SLang_get_int_type (int nbits); /* if nbits is negative it gets the signed int type, else unsigned int type */ SL_EXTERN int SLang_get_int_size (SLtype); /* Opposite of SLang_get_int_type */ /*{{{ Interpreter Macro Definitions */ /* The definitions here are for objects that may be on the run-time stack. * They are actually sub_types of literal and data main_types. The actual * numbers are historical. */ #define SLANG_UNDEFINED_TYPE 0x00 /* MUST be 0 */ #define SLANG_VOID_TYPE 0x01 /* also matches ANY type */ #define SLANG_NULL_TYPE (0x02) #define SLANG_ANY_TYPE (0x03) #define SLANG_DATATYPE_TYPE (0x04) /* SLANG_REF_TYPE refers to an object on the stack that is a pointer (reference) * to some other object. */ #define SLANG_REF_TYPE (0x05) #define SLANG_STRING_TYPE (0x06) #define SLANG_BSTRING_TYPE (0x07) #define SLANG_FILE_PTR_TYPE (0x08) #define SLANG_FILE_FD_TYPE (0x09) #define SLANG_MD5_TYPE (0x0A) #define SLANG_INTP_TYPE (0x0F) /* Integer types */ /* The integer and floating point types are arranged in order of arithmetic * precedence. */ #define SLANG_CHAR_TYPE (0x10) #define SLANG_UCHAR_TYPE (0x11) #define SLANG_SHORT_TYPE (0x12) #define SLANG_USHORT_TYPE (0x13) #define SLANG_INT_TYPE (0x14) #define SLANG_UINT_TYPE (0x15) #define SLANG_LONG_TYPE (0x16) #define SLANG_ULONG_TYPE (0x17) #define SLANG_LLONG_TYPE (0x18) #define SLANG_ULLONG_TYPE (0x19) /* floating point types */ #define SLANG_FLOAT_TYPE (0x1A) #define SLANG_DOUBLE_TYPE (0x1B) #define SLANG_LDOUBLE_TYPE (0x1C) #define SLANG_COMPLEX_TYPE (0x20) /* An object of SLANG_INTP_TYPE should never really occur on the stack. Rather, * the integer to which it refers will be there instead. It is defined here * because it is a valid type for MAKE_VARIABLE. */ /* Container types */ #define SLANG_ISTRUCT_TYPE (0x2A) #define SLANG_STRUCT_TYPE (0x2B) #define SLANG_ASSOC_TYPE (0x2C) #define SLANG_ARRAY_TYPE (0x2D) #define SLANG_LIST_TYPE (0x2E) #define SLANG_MIN_UNUSED_TYPE (0x30) /* Compatibility */ #ifdef FLOAT_TYPE # undef FLOAT_TYPE #endif #define VOID_TYPE SLANG_VOID_TYPE #define INT_TYPE SLANG_INT_TYPE #define INTP_TYPE SLANG_INTP_TYPE #define FLOAT_TYPE SLANG_DOUBLE_TYPE #define ARRAY_TYPE SLANG_ARRAY_TYPE #define CHAR_TYPE SLANG_CHAR_TYPE #define STRING_TYPE SLANG_STRING_TYPE /* I am reserving values greater than or equal to 128 for user applications. * The first 127 are reserved for S-Lang. */ /* Binary and Unary Subtypes */ /* Since the application can define new types and can overload the binary * and unary operators, these definitions must be present in this file. * The current implementation assumes both unary and binary are distinct. */ #define SLANG_BINARY_OP_MIN 0x01 #define SLANG_PLUS 0x01 #define SLANG_MINUS 0x02 #define SLANG_TIMES 0x03 #define SLANG_DIVIDE 0x04 #define SLANG_EQ 0x05 #define SLANG_NE 0x06 #define SLANG_GT 0x07 #define SLANG_GE 0x08 #define SLANG_LT 0x09 #define SLANG_LE 0x0A #define SLANG_POW 0x0B #define SLANG_OR 0x0C #define SLANG_AND 0x0D #define SLANG_BAND 0x0E #define SLANG_BOR 0x0F #define SLANG_BXOR 0x10 #define SLANG_SHL 0x11 #define SLANG_SHR 0x12 #define SLANG_MOD 0x13 #define SLANG_BINARY_OP_MAX 0x13 /* UNARY subtypes (may be overloaded) */ #define SLANG_UNARY_OP_MIN 0x20 #define SLANG_PLUSPLUS 0x20 #define SLANG_MINUSMINUS 0x21 #define SLANG_CHS 0x22 #define SLANG_NOT 0x23 #define SLANG_BNOT 0x24 /* These are implemented as unary function calls */ #define SLANG_ABS 0x25 #define SLANG_SIGN 0x26 #define SLANG_SQR 0x27 #define SLANG_MUL2 0x28 #define SLANG_ISPOS 0x29 #define SLANG_ISNEG 0x2A #define SLANG_ISNONNEG 0x2B #define SLANG_UNARY_OP_MAX 0x2B /* SL_EXTERN SLFUTURE_CONST char *SLang_Error_Message; */ SL_EXTERN int SLadd_intrinsic_variable (SLFUTURE_CONST char *, VOID_STAR, SLtype, int); SL_EXTERN int SLadd_intrinsic_function (SLFUTURE_CONST char *, FVOID_STAR, SLtype, unsigned int,...); SL_EXTERN int SLns_add_intrinsic_variable (SLang_NameSpace_Type *, SLFUTURE_CONST char *, VOID_STAR, SLtype, int); SL_EXTERN int SLns_add_intrinsic_function (SLang_NameSpace_Type *, SLFUTURE_CONST char *, FVOID_STAR, SLtype, unsigned int,...); /* These functions are used to patch intrinsic tables that make use of * dynamically allocated types whose type id is determined at * run-time. The second version is useful for the most common case of a * single mapping. */ SL_EXTERN int SLclass_patch_intrin_fun_table (SLang_Intrin_Fun_Type *table, SLtype *from_types, SLtype *to_types, unsigned int num); SL_EXTERN int SLclass_patch_intrin_fun_table1 (SLang_Intrin_Fun_Type *table, SLtype from_type, SLtype to_type); #define MAKE_INTRINSIC_N(n,f,out,in,a1,a2,a3,a4,a5,a6,a7) \ {(n), NULL, SLANG_INTRINSIC, (FVOID_STAR)(SLFvoid_Star)(f), \ {a1,a2,a3,a4,a5,a6,a7}, (in), (out)} #define MAKE_INTRINSIC_7(n,f,out,a1,a2,a3,a4,a5,a6,a7) \ MAKE_INTRINSIC_N(n,f,out,7,a1,a2,a3,a4,a5,a6,a7) #define MAKE_INTRINSIC_6(n,f,out,a1,a2,a3,a4,a5,a6) \ MAKE_INTRINSIC_N(n,f,out,6,a1,a2,a3,a4,a5,a6,0) #define MAKE_INTRINSIC_5(n,f,out,a1,a2,a3,a4,a5) \ MAKE_INTRINSIC_N(n,f,out,5,a1,a2,a3,a4,a5,0,0) #define MAKE_INTRINSIC_4(n,f,out,a1,a2,a3,a4) \ MAKE_INTRINSIC_N(n,f,out,4,a1,a2,a3,a4,0,0,0) #define MAKE_INTRINSIC_3(n,f,out,a1,a2,a3) \ MAKE_INTRINSIC_N(n,f,out,3,a1,a2,a3,0,0,0,0) #define MAKE_INTRINSIC_2(n,f,out,a1,a2) \ MAKE_INTRINSIC_N(n,f,out,2,a1,a2,0,0,0,0,0) #define MAKE_INTRINSIC_1(n,f,out,a1) \ MAKE_INTRINSIC_N(n,f,out,1,a1,0,0,0,0,0,0) #define MAKE_INTRINSIC_0(n,f,out) \ MAKE_INTRINSIC_N(n,f,out,0,0,0,0,0,0,0,0) #define MAKE_INTRINSIC_S(n,f,r) \ MAKE_INTRINSIC_1(n,f,r,SLANG_STRING_TYPE) #define MAKE_INTRINSIC_I(n,f,r) \ MAKE_INTRINSIC_1(n,f,r,SLANG_INT_TYPE) #define MAKE_INTRINSIC_SS(n,f,r) \ MAKE_INTRINSIC_2(n,f,r,SLANG_STRING_TYPE,SLANG_STRING_TYPE) #define MAKE_INTRINSIC_SI(n,f,r) \ MAKE_INTRINSIC_2(n,f,r,SLANG_STRING_TYPE,SLANG_INT_TYPE) #define MAKE_INTRINSIC_IS(n,f,r) \ MAKE_INTRINSIC_2(n,f,r,SLANG_INT_TYPE,SLANG_STRING_TYPE) #define MAKE_INTRINSIC_II(n,f,r) \ MAKE_INTRINSIC_2(n,f,r,SLANG_INT_TYPE,SLANG_INT_TYPE) #define MAKE_INTRINSIC_SSS(n,f,r) \ MAKE_INTRINSIC_3(n,f,r,SLANG_STRING_TYPE,SLANG_STRING_TYPE,SLANG_STRING_TYPE) #define MAKE_INTRINSIC_SSI(n,f,r) \ MAKE_INTRINSIC_3(n,f,r,SLANG_STRING_TYPE,SLANG_STRING_TYPE,SLANG_INT_TYPE) #define MAKE_INTRINSIC_SIS(n,f,r) \ MAKE_INTRINSIC_3(n,f,r,SLANG_STRING_TYPE,SLANG_INT_TYPE,SLANG_STRING_TYPE) #define MAKE_INTRINSIC_SII(n,f,r) \ MAKE_INTRINSIC_3(n,f,r,SLANG_STRING_TYPE,SLANG_INT_TYPE,SLANG_INT_TYPE) #define MAKE_INTRINSIC_ISS(n,f,r) \ MAKE_INTRINSIC_3(n,f,r,SLANG_INT_TYPE,SLANG_STRING_TYPE,SLANG_STRING_TYPE) #define MAKE_INTRINSIC_ISI(n,f,r) \ MAKE_INTRINSIC_3(n,f,r,SLANG_INT_TYPE,SLANG_STRING_TYPE,SLANG_INT_TYPE) #define MAKE_INTRINSIC_IIS(n,f,r) \ MAKE_INTRINSIC_3(n,f,r,SLANG_INT_TYPE,SLANG_INT_TYPE,SLANG_STRING_TYPE) #define MAKE_INTRINSIC_III(n,f,r) \ MAKE_INTRINSIC_3(n,f,r,SLANG_INT_TYPE,SLANG_INT_TYPE,SLANG_INT_TYPE) #define MAKE_INTRINSIC(n, f, out, in) \ MAKE_INTRINSIC_N(n,f,out,in,0,0,0,0,0,0,0) #define MAKE_VARIABLE(n, v, t, r) \ {n, NULL, SLANG_IVARIABLE + (r), (VOID_STAR)(v), (t)} #define MAKE_APP_UNARY(n,op) \ {(n), NULL, SLANG_APP_UNARY, (op)} #define MAKE_ARITH_UNARY(n,op) \ {(n), NULL, SLANG_ARITH_UNARY, (op)} #define MAKE_ARITH_BINARY(n,op) \ {(n), NULL, SLANG_ARITH_BINARY, (op)} #define MAKE_MATH_UNARY(n,op) \ {(n), NULL, SLANG_MATH_UNARY, (op)} #define MAKE_HCONSTANT_T(n,val,T) \ {(n),NULL, SLANG_HCONSTANT, T, (short)(val)} #define MAKE_HCONSTANT(n,val) MAKE_HCONSTANT_T(n,val,SLANG_SHORT_TYPE) #define MAKE_ICONSTANT_T(n,val,T) \ {(n),NULL, SLANG_ICONSTANT, T, (int)(val)} #define MAKE_ICONSTANT(n,val) MAKE_ICONSTANT_T(n,val,SLANG_INT_TYPE) #define MAKE_LCONSTANT_T(n,val,T) \ {(n),NULL, SLANG_LCONSTANT, T, (long)(val)} #define MAKE_LCONSTANT(n,val) MAKE_LCONSTANT_T(n,val,SLANG_LONG_TYPE) #ifdef HAVE_LONG_LONG # define MAKE_LLCONSTANT_T(n,val,T) \ {(n),NULL, T, (long long)(val)} # define MAKE_LLCONSTANT(n,val) MAKE_LLCONSTANT_T(n,val,SLANG_LLONG_TYPE) #endif #define MAKE_FCONSTANT(n,val) \ {(n),NULL, SLANG_FCONSTANT, (val)} #define MAKE_DCONSTANT(n,val) \ {(n),NULL, SLANG_DCONSTANT, (val)} #ifndef offsetof # define offsetof(T,F) ((unsigned int)((char *)&((T *)0L)->F - (char *)0L)) #endif #define MAKE_ISTRUCT_FIELD(s,f,n,t,r) {(n), offsetof(s,f), (t), (r)} #define MAKE_CSTRUCT_FIELD(s,f,n,t,r) {(n), offsetof(s,f), (t), (r)} #define MAKE_CSTRUCT_INT_FIELD(s,f,n,r) {(n), offsetof(s,f),\ (sizeof(((s*)0L)->f)==sizeof(int))?(SLANG_INT_TYPE): \ (sizeof(((s*)0L)->f)==sizeof(short))?(SLANG_SHORT_TYPE): \ (sizeof(((s*)0L)->f)==sizeof(char))?(SLANG_CHAR_TYPE): \ (sizeof(((s*)0L)->f)==sizeof(long))?(SLANG_LONG_TYPE): \ SLANG_LLONG_TYPE, (r)\ } #define MAKE_CSTRUCT_UINT_FIELD(s,f,n,r) {(n), offsetof(s,f),\ (sizeof(((s*)0L)->f)==sizeof(int))?(SLANG_UINT_TYPE): \ (sizeof(((s*)0L)->f)==sizeof(short))?(SLANG_USHORT_TYPE): \ (sizeof(((s*)0L)->f)==sizeof(char))?(SLANG_UCHAR_TYPE): \ (sizeof(((s*)0L)->f)==sizeof(long))?(SLANG_ULONG_TYPE): \ SLANG_ULLONG_TYPE, (r)\ } #define MAKE_CSTRUCT_FLOAT_FIELD(s,f,n,r) {(n), offsetof(s,f),\ (sizeof(((s*)0L)->f)==sizeof(float))?(SLANG_FLOAT_TYPE): \ SLANG_DOUBLE_TYPE, (r)\ } #define SLANG_END_TABLE {NULL} #define SLANG_END_INTRIN_FUN_TABLE MAKE_INTRINSIC_0(NULL,NULL,0) #define SLANG_END_FCONST_TABLE MAKE_DCONSTANT(NULL,0) #define SLANG_END_DCONST_TABLE MAKE_DCONSTANT(NULL,0) #define SLANG_END_MATH_UNARY_TABLE MAKE_MATH_UNARY(NULL,0) #define SLANG_END_ARITH_UNARY_TABLE MAKE_ARITH_UNARY(NULL,0) #define SLANG_END_ARITH_BINARY_TABLE MAKE_ARITH_BINARY(NULL,0) #define SLANG_END_APP_UNARY_TABLE MAKE_APP_UNARY(NULL,0) #define SLANG_END_INTRIN_VAR_TABLE MAKE_VARIABLE(NULL,NULL,0,0) #define SLANG_END_ICONST_TABLE MAKE_ICONSTANT(NULL,0) #define SLANG_END_LCONST_TABLE MAKE_LCONSTANT(NULL,0) #define SLANG_END_LLCONST_TABLE MAKE_LLCONSTANT(NULL,0) #define SLANG_END_ISTRUCT_TABLE {NULL, 0, 0, 0} #define SLANG_END_CSTRUCT_TABLE {NULL, 0, 0, 0} /*}}}*/ /*{{{ Upper/Lowercase Functions */ SL_EXTERN void SLang_define_case(int *, int *); SL_EXTERN void SLang_init_case_tables (void); SL_EXTERN unsigned char _pSLChg_UCase_Lut[256]; SL_EXTERN unsigned char _pSLChg_LCase_Lut[256]; #define UPPER_CASE(x) (_pSLChg_UCase_Lut[(unsigned char) (x)]) #define LOWER_CASE(x) (_pSLChg_LCase_Lut[(unsigned char) (x)]) #define CHANGE_CASE(x) (((x) == _pSLChg_LCase_Lut[(unsigned char) (x)]) ?\ _pSLChg_UCase_Lut[(unsigned char) (x)] : _pSLChg_LCase_Lut[(unsigned char) (x)]) /*}}}*/ /*{{{ Regular Expression Interface */ typedef struct _pSLRegexp_Type SLRegexp_Type; SL_EXTERN SLRegexp_Type *SLregexp_compile (SLFUTURE_CONST char *pattern, unsigned int flags); #define SLREGEXP_CASELESS 0x01 #define SLREGEXP_UTF8 0x10 SL_EXTERN void SLregexp_free (SLRegexp_Type *); SL_EXTERN char *SLregexp_match (SLRegexp_Type *compiled_regexp, SLFUTURE_CONST char *str, SLstrlen_Type len); SL_EXTERN int SLregexp_nth_match (SLRegexp_Type *, unsigned int nth, SLstrlen_Type *ofsp, SLstrlen_Type *lenp); SL_EXTERN int SLregexp_get_hints (SLRegexp_Type *, unsigned int *flagsp); #define SLREGEXP_HINT_BOL 0x01 /* pattern must match bol */ #define SLREGEXP_HINT_OSEARCH 0x02 /* ordinary search will do */ SL_EXTERN char *SLregexp_quote_string (SLFUTURE_CONST char *pattern, char *buf, unsigned int buflen); /*}}}*/ /*{{{ SLang Command Interface */ struct _pSLcmd_Cmd_Type; /* Pre-declaration is needed below */ typedef struct { struct _pSLcmd_Cmd_Type *table; int argc; /* Version 2.0 needs to use a union!! */ SLFUTURE_CONST char **string_args; int *int_args; double *double_args; SLtype *arg_type; unsigned long reserved[4]; } SLcmd_Cmd_Table_Type; typedef struct _pSLcmd_Cmd_Type { int (*cmdfun)(int, SLcmd_Cmd_Table_Type *); SLFUTURE_CONST char *cmd; SLFUTURE_CONST char *arg_type; } SLcmd_Cmd_Type; SL_EXTERN int SLcmd_execute_string (SLFUTURE_CONST char *, SLcmd_Cmd_Table_Type *); /*}}}*/ /*{{{ SLang Search Interface */ typedef struct _pSLsearch_Type SLsearch_Type; SL_EXTERN SLsearch_Type *SLsearch_new (SLuchar_Type *u, int search_flags); #define SLSEARCH_CASELESS 0x1 #define SLSEARCH_UTF8 0x2 SL_EXTERN void SLsearch_delete (SLsearch_Type *); SL_EXTERN SLuchar_Type *SLsearch_forward (SLsearch_Type *st, SLuchar_Type *pmin, SLuchar_Type *pmax); SL_EXTERN SLuchar_Type *SLsearch_backward (SLsearch_Type *st, SLuchar_Type *pmin, SLuchar_Type *pstart, SLuchar_Type *pmax); SL_EXTERN SLstrlen_Type SLsearch_match_len (SLsearch_Type *); /*}}}*/ /*{{{ SLang Pathname Interface */ /* These function return pointers to the original space */ SL_EXTERN char *SLpath_basename (SLFUTURE_CONST char *); SL_EXTERN char *SLpath_extname (SLFUTURE_CONST char *); SL_EXTERN int SLpath_is_absolute_path (SLFUTURE_CONST char *); /* Get and set the character delimiter for search paths */ SL_EXTERN int SLpath_get_delimiter (void); SL_EXTERN int SLpath_set_delimiter (int); /* search path for loading .sl files */ SL_EXTERN int SLpath_set_load_path (SLFUTURE_CONST char *); /* search path for loading .sl files --- returns slstring */ SL_EXTERN char *SLpath_get_load_path (void); /* These return malloced strings--- NOT slstrings */ SL_EXTERN char *SLpath_dircat (SLFUTURE_CONST char *, SLFUTURE_CONST char *); SL_EXTERN char *SLpath_find_file_in_path (SLFUTURE_CONST char *, SLFUTURE_CONST char *); SL_EXTERN char *SLpath_dirname (SLFUTURE_CONST char *); SL_EXTERN int SLpath_file_exists (SLFUTURE_CONST char *); SL_EXTERN char *SLpath_pathname_sans_extname (SLFUTURE_CONST char *); SL_EXTERN char *SLpath_getcwd (void); /* return NULL on error, sets errno */ /*}}}*/ SL_EXTERN int SLang_set_module_load_path (SLFUTURE_CONST char *); #ifdef __cplusplus # define SLANG_MODULE(name) \ extern SL_EXPORT "C" int init_##name##_module_ns (char *); \ extern SL_EXPORT "C" void deinit_##name##_module (void); \ extern SL_EXPORT "C" int SLmodule_##name##_api_version; \ SL_EXPORT int SLmodule_##name##_api_version = SLANG_VERSION #else # define SLANG_MODULE(name) \ extern SL_EXPORT int init_##name##_module_ns (char *); \ extern SL_EXPORT void deinit_##name##_module (void); \ SL_EXPORT int SLmodule_##name##_api_version = SLANG_VERSION #endif SL_EXTERN int SLvsnprintf (char *, unsigned int, SLFUTURE_CONST char *, va_list); SL_EXTERN int SLsnprintf (char *, unsigned int, SLFUTURE_CONST char *, ...) SLATTRIBUTE_PRINTF(3,4); #if 0 { #endif #ifdef __cplusplus } #endif #endif /* DAVIS_SLANG_H_ */