/* $XdotOrg: xc/programs/xedit/lisp/internal.h,v 1.2 2004/04/23 19:54:44 eich Exp $ */ /* * Copyright (c) 2001 by The XFree86 Project, Inc. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. * * Except as contained in this notice, the name of the XFree86 Project shall * not be used in advertising or otherwise to promote the sale, use or other * dealings in this Software without prior written authorization from the * XFree86 Project. * * Author: Paulo César Pereira de Andrade */ /* $XFree86: xc/programs/xedit/lisp/internal.h,v 1.50tsi Exp $ */ #ifndef Lisp_internal_h #define Lisp_internal_h #include #include "lisp/lisp.h" #include "mp.h" #include "re.h" #include "util.h" /* * Defines */ typedef struct _LispMac LispMac; #define STREAM_READ 0x01 #define STREAM_WRITE 0x02 #define STREAM_BINARY 0x20 #define RPLACA(cons, object) (CAR(cons) = object) #define RPLACD(cons, object) (CDR(cons) = object) #define CAR(list) ((list)->data.cons.car) #define CAAR(list) ((list)->data.cons.car->data.cons.car) #define CADR(list) ((list)->data.cons.cdr->data.cons.car) #define CDR(list) ((list)->data.cons.cdr) #define CDAR(list) ((list)->data.cons.car->data.cons.cdr) #define CDDR(list) ((list)->data.cons.cdr->data.cons.cdr) #define CONS(car, cdr) LispNewCons(car, cdr) #define EVAL(list) LispEval(list) #define APPLY(fun, args) LispFuncall(fun, args, 0) #define APPLY1(fun, arg) LispApply1(fun, arg) #define APPLY2(fun, arg1, arg2) LispApply2(fun, arg1, arg2) #define APPLY3(f, a1, a2, a3) LispApply3(f, a1, a2, a3) #define EXECUTE(string) LispExecute(string) #define SYMBOL(atom) LispNewSymbol(atom) #define ATOM(string) LispNewAtom(string, 1) #define UNINTERNED_ATOM(string) LispNewAtom(string, 0) #define FUNCTION(symbol) LispNewFunction(symbol) #define FUNCTION_QUOTE(symbol) LispNewFunctionQuote(symbol) /* atom string is a static variable */ #define ATOM2(string) LispNewSymbol(LispGetPermAtom(string)) /* make a gc never released variable with a static string argument */ #define STATIC_ATOM(string) LispNewStaticAtom(string) #define STRING(str) LispNewString(str, strlen(str)) #define LSTRING(str, size) LispNewString(str, size) /* string must be from the LispXXX allocation functions, * and LispMused not yet called on it */ #define STRING2(str) LispNewStringAlloced(str, strlen(str)) #define LSTRING2(str, size) LispNewStringAlloced(str, size) #define VECTOR(objects) LispNewVector(objects) /* STRINGSTREAM2 and LSTRINGSTREAM2 require that the * string be allocated from the LispXXX allocation functions, * and LispMused not yet called on it */ #define STRINGSTREAM(str, flag) \ LispNewStringStream(str, flag, strlen(str)) #define STRINGSTREAM2(str, flag) \ LispNewStringStreamAlloced(str, flag, strlen(str)) #define LSTRINGSTREAM(str, flag, length) \ LispNewStringStream(str, flag, length) #define LSTRINGSTREAM2(str, flag, length) \ LispNewStringStreamAlloced(str, flag, length) #define FILESTREAM(file, path, flag) \ LispNewFileStream(file, path, flag) #define PIPESTREAM(file, path, flag) \ LispNewPipeStream(file, path, flag) #define CHECKO(obj, typ) \ ((obj)->type == LispOpaque_t && \ ((obj)->data.opaque.type == typ || (obj)->data.opaque.type == 0)) #define PROTECT(key, list) LispProtect(key, list) #define UPROTECT(key, list) LispUProtect(key, list) /* create a new unique static atom string */ #define GETATOMID(string) LispGetAtomKey(string, 1) #define GCDisable() ++gcpro #define GCEnable() --gcpro /* pointer to something unique to all atoms with the same print representation */ #define ATOMID(object) (object)->data.atom->key #define NIL_BIT 0x01 #define FIXNUM_BIT 0x02 #define FIXNUM_MASK 0x03 #define SCHAR_BIT 0x04 #define SCHAR_MASK 0x05 #define BIT_COUNT 4 #define BIT_MASK 0x0f #define POINTERP(object) \ (((unsigned long)(object) & NIL_BIT) == 0) #define MOST_POSITIVE_FIXNUM ((1L << (sizeof(long) * 8 - 5)) - 1) #define MOST_NEGATIVE_FIXNUM (-1L << (sizeof(long) * 8 - 5)) #define SCHAR(value) \ ((LispObj*)(((long)(value) << BIT_COUNT) | SCHAR_MASK)) #define SCHAR_VALUE(object) FIXNUM_VALUE(object) #define SCHARP(object) \ (((unsigned long)(object) & BIT_MASK) == SCHAR_MASK) #define CHECK_SCHAR(object) \ if (!SCHARP(object)) \ LispDestroy("%s: %s is not a character", \ STRFUN(builtin), STROBJ(object)) #define XOBJECT_TYPE(object) ((object)->type) #define OBJECT_TYPE(object) (POINTERP(object) ? \ XOBJECT_TYPE(object) : \ (LispType)((long)(object) & BIT_MASK)) #define NIL (LispObj*)0x00000001 #define T (LispObj*)0x00000011 #define DOT (LispObj*)0x00000021 /* unmatched ')' */ #define EOLIST (LispObj*)0x00000031 #define READLABEL_MASK 0x00000041 /* unspecified argument */ #define UNSPEC (LispObj*)0x00000051 #define INVALIDP(object) \ ((object) == NULL || (object) == EOLIST || (object) == DOT) /* cons */ #define XCONSP(object) ((object)->type == LispCons_t) #define CONSP(object) (POINTERP(object) && XCONSP(object)) #define CHECK_CONS(object) \ if (!CONSP(object)) \ LispDestroy("%s: %s is not of type cons", \ STRFUN(builtin), STROBJ(object)) #define LISTP(object) (object == NIL || CONSP(object)) #define CHECK_LIST(object) \ if (!LISTP(object)) \ LispDestroy("%s: %s is not a list", \ STRFUN(builtin), STROBJ(object)) /* fixnum */ #define FIXNUM(value) \ ((LispObj*)(((long)(value) << BIT_COUNT) | FIXNUM_MASK)) #define FIXNUM_VALUE(object) ((long)(object) >> BIT_COUNT) #define FIXNUMP(object) \ (((unsigned long)(object) & BIT_MASK) == FIXNUM_MASK) #define CHECK_FIXNUM(object) \ if (!FIXNUMP(object)) \ LispDestroy("%s: %s is not a fixnum", \ STRFUN(builtin), STROBJ(object)) #define INDEXP(object) \ (FIXNUMP(object) && FIXNUM_VALUE(object) >= 0) #define CHECK_INDEX(object) \ if (!INDEXP(object)) \ LispDestroy("%s: %s is not a positive fixnum", \ STRFUN(builtin), STROBJ(object)) /* long int integer */ #define XINTP(object) ((object)->type == LispInteger_t) #define INTP(objet) (POINTERP(object) && XINTP(object)) #define INT_VALUE(object) (object)->data.integer /* values that fit in a machine long int but not in a fixnum */ #define LONGINTP(object) \ (POINTERP(object) ? XINTP(object) : FIXNUMP(object)) #define LONGINT_VALUE(object) \ (POINTERP(object) ? INT_VALUE(object) : FIXNUM_VALUE(object)) #define CHECK_LONGINT(object) \ if (!LONGINTP(object)) \ LispDestroy("%s: %s is not an integer", \ STRFUN(builtin), STROBJ(object)) /* bignum */ #define XBIGNUMP(object) ((object)->type == LispBignum_t) #define BIGNUMP(object) (POINTERP(object) && XBIGNUMP(object)) #define BIGNUM(object) LispNewBignum(object) /* generic integer */ #define INTEGER(integer) LispNewInteger(integer) #define INTEGERP(object) \ (POINTERP(object) ? XINTP(object) || XBIGNUMP(object) : FIXNUMP(object)) #define CHECK_INTEGER(object) \ if (!INTEGERP(object)) \ LispDestroy("%s: %s is not an integer", \ STRFUN(builtin), STROBJ(object)) /* ratio */ #define XRATIOP(object) ((object)->type == LispRatio_t) #define RATIOP(object) (POINTERP(object) && XRATIOP(object)) #define RATIO(num, den) LispNewRatio(num, den) /* bigratio */ #define XBIGRATIOP(object) ((object)->type == LispBigratio_t) #define BIGRATIOP(object) (POINTERP(object) && XBIGRATIOP(object)) #define BIGRATIO(ratio) LispNewBigratio(ratio) /* generic rational */ #define RATIONALP(object) \ (POINTERP(object) ? XINTP(object) || XRATIOP(object) || \ XBIGNUMP(object) || XBIGRATIOP(object) : \ FIXNUMP(object)) /* double float */ #define XDFLOATP(object) ((object)->type == LispDFloat_t) #define DFLOATP(object) (POINTERP(object) && XDFLOATP(object)) #define DFLOAT_VALUE(object) (object)->data.dfloat #define CHECK_DFLOAT(object) \ if (!DFLOATP(object)) \ LispDestroy("%s: %s is not a float number", \ STRFUN(builtin), STROBJ(object)) #define DFLOAT(value) LispNewDFloat(value) /* generic float - currently only double float supported */ #define FLOATP(object) DFLOATP(object) /* real number */ #define REALP(object) \ (POINTERP(object) ? XINTP(object) || XDFLOATP(object) || \ XRATIOP(object) || XBIGNUMP(object) || \ XBIGRATIOP(object) : \ FIXNUMP(object)) #define CHECK_REAL(object) \ if (!REALP(object)) \ LispDestroy("%s: %s is not a real number", \ STRFUN(builtin), STROBJ(object)) /* complex */ #define XCOMPLEXP(object) ((object)->type == LispComplex_t) #define COMPLEXP(object) (POINTERP(object) && XCOMPLEXP(object)) #define COMPLEX(real, imag) LispNewComplex(real, imag) /* generic number */ #define NUMBERP(object) \ (POINTERP(object) ? XINTP(object) || XDFLOATP(object) || \ XRATIOP(object) || XBIGNUMP(object) || \ XBIGRATIOP(object) || XCOMPLEXP(object) : \ FIXNUMP(object)) #define CHECK_NUMBER(object) \ if (!NUMBERP(object)) \ LispDestroy("%s: %s is not a number", \ STRFUN(builtin), STROBJ(object)) /* symbol */ #define XSYMBOLP(object) ((object)->type == LispAtom_t) #define SYMBOLP(object) (POINTERP(object) && XSYMBOLP(object)) #define CHECK_SYMBOL(object) \ if (!SYMBOLP(object)) \ LispDestroy("%s: %s is not a symbol", \ STRFUN(builtin), STROBJ(object)) /* keyword */ #define XKEYWORDP(object) \ ((object)->data.atom->package == lisp__data.keyword) #define KEYWORDP(object) \ (POINTERP(object) && XSYMBOLP(object) && XKEYWORDP(object)) #define KEYWORD(string) LispNewKeyword(string) #define CHECK_KEYWORD(object) \ if (!KEYWORDP(object)) \ LispDestroy("%s: %s is not a keyword", \ STRFUN(builtin), STROBJ(object)) #define CHECK_CONSTANT(object) \ if ((object)->data.atom->constant) \ LispDestroy("%s: %s is a constant", \ STRFUN(builtin), STROBJ(object)) #define SETVALUE(atom, object) ((atom)->property->value = object) /* function */ #define XFUNCTIONP(object) ((object)->type == LispFunction_t) #define FUNCTIONP(object) (POINTERP(object) && XFUNCTIONP(object)) /* lambda */ #define XLAMBDAP(object) ((object)->type == LispLambda_t) #define LAMBDAP(object) (POINTERP(object) && XLAMBDAP(object)) /* string - currently only simple 8 bit characters */ #define XSTRINGP(object) ((object)->type == LispString_t) #define STRINGP(object) (POINTERP(object) && XSTRINGP(object)) #define THESTR(object) (object)->data.string.string #define STRLEN(object) (object)->data.string.length #define CHECK_STRING(object) \ if (!STRINGP(object)) \ LispDestroy("%s: %s is not a string", \ STRFUN(builtin), STROBJ(object)) #define CHECK_STRING_WRITABLE(object) \ if (!object->data.string.writable) \ LispDestroy("%s: %s is readonly", \ STRFUN(builtin), STROBJ(object)) /* array/vector */ #define XARRAYP(object) ((object)->type == LispArray_t) #define ARRAYP(object) (POINTERP(object) && XARRAYP(object)) #define CHECK_ARRAY(object) \ if (!ARRAYP(object)) \ LispDestroy("%s: %s is not an array", \ STRFUN(builtin), STROBJ(object)) /* quote */ #define XQUOTEP(object) ((object)->type == LispQuote_t) #define QUOTEP(object) (POINTERP(object) && XQUOTEP(object)) #define QUOTE(object) LispNewQuote(object) #define XBACKQUOTEP(object) ((object)->type == LispBackquote_t) #define BACKQUOTEP(object) (POINTERP(object) && XBACKQUOTEP(object)) #define BACKQUOTE(object) LispNewBackquote(object) #define XCOMMAP(object) ((object)->type == LispComma_t) #define COMMAP(object) (POINTERP(object) && XCOMMAP(object)) #define COMMA(object, at) LispNewComma(object, at) /* package */ #define XPACKAGEP(object) ((object)->type == LispPackage_t) #define PACKAGEP(object) (POINTERP(object) && XPACKAGEP(object)) /* pathname */ #define XPATHNAMEP(object) ((object)->type == LispPathname_t) #define PATHNAMEP(object) (POINTERP(object) && XPATHNAMEP(object)) #define PATHNAME(object) LispNewPathname(object) #define CHECK_PATHNAME(object) \ if (!PATHNAMEP(object)) \ LispDestroy("%s: %s is not a pathname", \ STRFUN(builtin), STROBJ(object)) /* stream */ #define XSTREAMP(object) ((object)->type == LispStream_t) #define STREAMP(object) (POINTERP(object) && XSTREAMP(object)) #define CHECK_STREAM(object) \ if (!STREAMP(object)) \ LispDestroy("%s: %s is not a stream", \ STRFUN(builtin), STROBJ(object)) /* hastable */ #define XHASHTABLEP(object) ((object)->type == LispHashTable_t) #define HASHTABLEP(object) (POINTERP(object) && XHASHTABLEP(object)) #define CHECK_HASHTABLE(object) \ if (!HASHTABLEP(object)) \ LispDestroy("%s: %s is not a hash-table", \ STRFUN(builtin), STROBJ(object)) /* regex */ #define XREGEXP(object) ((object)->type == LispRegex_t) #define REGEXP(object) (POINTERP(object) && XREGEXP(object)) #define CHECK_REGEX(object) \ if (!REGEXP(object)) \ LispDestroy("%s: %s is not a regexp", \ STRFUN(builtin), STROBJ(object)) /* bytecode */ #define XBYTECODEP(object) ((object)->type == LispBytecode_t) #define BYTECODEP(object) (POINTERP(object) && XBYTECODEP(object)) /* opaque */ #define XOPAQUEP(object) ((object)->type == LispOpaque_t) #define OPAQUEP(object) (POINTERP(object) && XOPAQUEP(object)) #define OPAQUE(data, type) LispNewOpaque((void*)((long)data), type) #define SSTREAMP(str) ((str)->data.stream.source.string) #define FSTREAMP(str) ((str)->data.stream.source.file) #define PSTREAMP(str) ((str)->data.stream.source.program) #define PIDPSTREAMP(str) ((str)->data.stream.source.program->pid) #define IPSTREAMP(str) ((str)->data.stream.source.program->input) #define OPSTREAMP(str) ((str)->data.stream.source.program->output) #define EPSTREAMP(str) \ FSTREAMP((str)->data.stream.source.program->errorp) #define LispFileno(file) ((file)->descriptor) #define STRFUN(builtin) ATOMID(builtin->symbol)->value #define STROBJ(obj) LispStrObj(obj) /* fetch builtin function/macro argument value */ #define ARGUMENT(index) \ lisp__data.stack.values[lisp__data.stack.base + (index)] #define RETURN(index) lisp__data.returns.values[(index)] #define RETURN_COUNT lisp__data.returns.count #define RETURN_CHECK(value) \ value < MULTIPLE_VALUES_LIMIT ? \ value : MULTIPLE_VALUES_LIMIT #define GC_ENTER() int gc__protect = lisp__data.protect.length #define GC_PROTECT(object) \ if (lisp__data.protect.length >= lisp__data.protect.space) \ LispMoreProtects(); \ lisp__data.protect.objects[lisp__data.protect.length++] = object #define GC_LEAVE() lisp__data.protect.length = gc__protect #define ERROR_CHECK_SPECIAL_FORM(atom) \ if ((atom)->property->fun.builtin->compile) \ LispDestroy("%s: the special form %s cannot be redefined", \ STRFUN(builtin), (atom)->key->value) #define CONSTANTP(object) \ (!POINTERP(object) || \ XOBJECT_TYPE(object) < LispAtom_t || \ (XSYMBOLP(object) && XKEYWORDP(object))) /* slightly faster test, since keywords are very uncommon as eval arguments */ #define NCONSTANTP(object) \ (OBJECT_TYPE(object) >= LispAtom_t) /* * Types */ typedef struct _LispObj LispObj; typedef struct _LispAtom LispAtom; typedef struct _LispBuiltin LispBuiltin; typedef struct _LispModuleData LispModuleData; typedef struct _LispFile LispFile; typedef struct _LispString LispString; typedef struct _LispPackage LispPackage; typedef struct _LispBytecode LispBytecode; typedef struct _LispHashTable LispHashTable; /* Bytecode compiler data */ typedef struct _LispCom LispCom; typedef hash_key *Atom_id; typedef enum _LispType { /* objects encoded in the LispObj pointer */ LispNil_t = 1, LispFixnum_t = 3, LispSChar_t = 5, /* objects that have a structure */ LispInteger_t = 16, LispDFloat_t, LispString_t, LispRatio_t, LispOpaque_t, /* simple access for marking */ LispBignum_t, LispBigratio_t, LispAtom_t, LispFunction_t, LispFunctionQuote_t, LispLambda_t, LispComplex_t, LispCons_t, LispQuote_t, LispArray_t, LispStruct_t, LispStream_t, LispBackquote_t, LispComma_t, LispPathname_t, LispPackage_t, LispRegex_t, LispBytecode_t, LispHashTable_t } LispType; typedef enum _LispFunType { LispLambda, LispFunction, LispMacro, LispSetf } LispFunType; typedef enum _LispStreamType { LispStreamString, LispStreamFile, LispStreamStandard, LispStreamPipe } LispStreamType; typedef struct { int pid; /* process id of program */ LispFile *input; /* if READABLE: stdout of program */ LispFile *output; /* if WRITABLE: stdin of program */ LispObj *errorp; /* ALWAYS (ONLY) READABLE: stderr of program */ } LispPipe; /* silly IBM compiler */ #ifdef AIXV5 /* probably want !gcc too */ #define LispType int #define LispFunType int #define LispStreamType int #endif struct _LispObj { LispType type : 6; unsigned int mark : 1; /* gc protected */ unsigned int prot: 1; /* protection for constant/unamed variables */ LispFunType funtype : 4; /* this is subject to change in the future */ union { LispAtom *atom; struct { char *string; long length; unsigned int writable : 1; } string; long integer; double dfloat; LispObj *quote; LispObj *pathname; /* don't use quote generic name, * to avoid confusing code */ struct { long numerator; long denominator; } ratio; union { mpi *integer; mpr *ratio; } mp; struct { LispObj *real; LispObj *imag; } complex; struct { LispObj *car; LispObj *cdr; } cons; struct { LispObj *name; LispObj *code; LispObj *data; /* extra data to protect */ } lambda; struct { LispObj *list; /* stored as a linear list */ LispObj *dim; /* dimensions of array */ unsigned int rank : 8; /* i.e. array-rank-limit => 256 */ unsigned int type : 7; /* converted to LispType, if not * Lisp_Nil_t only accepts given * type in array fields */ unsigned int zero : 1; /* at least one of the dimensions * is zero */ } array; struct { LispObj *fields; /* structure fields */ LispObj *def; /* structure definition */ } struc; struct { union { LispFile *file; LispPipe *program; LispString *string; } source; LispObj *pathname; LispStreamType type : 6; unsigned int readable : 1; unsigned int writable : 1; } stream; struct { void *data; int type; } opaque; struct { LispObj *eval; int atlist; } comma; struct { LispObj *name; LispObj *nicknames; LispPackage *package; } package; struct { re_cod *regex; LispObj *pattern; /* regex string */ int options; /* regex compile flags */ } regex; struct { LispBytecode *bytecode; LispObj *code; /* object used to generate bytecode */ LispObj *name; /* name of function, or NIL */ } bytecode; struct { LispHashTable *table; LispObj *test; } hash; } data; }; #ifdef AIXV5 #undef LispType #undef LispFunType #undef LispStreamType #endif typedef LispObj *(*LispFunPtr)(LispBuiltin*); typedef void (*LispComPtr)(LispCom*, LispBuiltin*); struct _LispBuiltin { /* these fields must be set */ LispFunType type; LispFunPtr function; const char *declaration; /* this field is optional, set if the function returns multiple values */ int multiple_values; /* this field is also optional, set if the function should not be exported */ int internal; /* this optional field points to a function of the bytecode compiler */ LispComPtr compile; /* this field is set at runtime */ LispObj *symbol; }; typedef int (*LispLoadModule)(void); typedef int (*LispUnloadModule)(void); #define LISP_MODULE_VERSION 1 struct _LispModuleData { int version; LispLoadModule load; LispUnloadModule unload; }; /* * Prototypes */ LispObj *LispEval(LispObj*); LispObj *LispFuncall(LispObj*, LispObj*, int); LispObj *LispApply1(LispObj*, LispObj*); LispObj *LispApply2(LispObj*, LispObj*, LispObj*); LispObj *LispApply3(LispObj*, LispObj*, LispObj*, LispObj*); LispObj *LispNew(LispObj*, LispObj*); LispObj *LispNewSymbol(LispAtom*); LispObj *LispNewAtom(const char*, int); LispObj *LispNewFunction(LispObj*); LispObj *LispNewFunctionQuote(LispObj*); LispObj *LispNewStaticAtom(const char*); LispObj *LispNewDFloat(double); LispObj *LispNewString(const char*, long); LispObj *LispNewStringAlloced(char*, long); LispObj *LispNewInteger(long); LispObj *LispNewRatio(long, long); LispObj *LispNewVector(LispObj*); LispObj *LispNewQuote(LispObj*); LispObj *LispNewBackquote(LispObj*); LispObj *LispNewComma(LispObj*, int); LispObj *LispNewCons(LispObj*, LispObj*); LispObj *LispNewLambda(LispObj*, LispObj*, LispObj*, LispFunType); LispObj *LispNewStruct(LispObj*, LispObj*); LispObj *LispNewComplex(LispObj*, LispObj*); LispObj *LispNewOpaque(void*, int); LispObj *LispNewKeyword(const char*); LispObj *LispNewPathname(LispObj*); LispObj *LispNewStringStream(const char*, int, long); LispObj *LispNewStringStreamAlloced(char*, int, long); LispObj *LispNewFileStream(LispFile*, LispObj*, int); LispObj *LispNewPipeStream(LispPipe*, LispObj*, int); LispObj *LispNewBignum(mpi*); LispObj *LispNewBigratio(mpr*); LispAtom *LispGetAtom(const char*); /* This function does not allocate a copy of it's argument, but the argument * itself. The argument string should never change. */ LispAtom *LispGetPermAtom(const char*); void *LispMalloc(size_t); void *LispCalloc(size_t, size_t); void *LispRealloc(void*, size_t); char *LispStrdup(const char*); void LispFree(void*); /* LispMused means memory is now safe from LispDestroy, and should not be * freed in case of an error */ void LispMused(void*); void LispGC(LispObj*, LispObj*); char *LispStrObj(LispObj*); #ifdef __GNUC__ #define PRINTF_FORMAT __attribute__ ((format (printf, 1, 2))) #else #define PRINTF_FORMAT /**/ #endif void LispDestroy(const char *fmt, ...) PRINTF_FORMAT; /* continuable error */ void LispContinuable(const char *fmt, ...) PRINTF_FORMAT; void LispMessage(const char *fmt, ...) PRINTF_FORMAT; void LispWarning(const char *fmt, ...) PRINTF_FORMAT; #undef PRINTF_FORMAT LispObj *LispSetVariable(LispObj*, LispObj*, const char*, int); int LispRegisterOpaqueType(const char*); void LispProtect(LispObj*, LispObj*); void LispUProtect(LispObj*, LispObj*); /* this function should be called when a module is loaded, and is called * when loading the interpreter */ void LispAddBuiltinFunction(LispBuiltin*); /* * Initialization */ extern LispObj *UNBOUND; extern int gcpro; extern LispObj *Okey, *Orest, *Ooptional, *Oaux, *Olambda; extern Atom_id Snil, St, Skey, Srest, Soptional, Saux; extern Atom_id Sand, Sor, Snot; extern Atom_id Satom, Ssymbol, Sinteger, Scharacter, Sstring, Slist, Scons, Svector, Sarray, Sstruct, Skeyword, Sfunction, Spathname, Srational, Sfloat, Scomplex, Sopaque, Sdefault; extern LispObj *Ocomplex, *Oformat, *Kunspecific; extern LispObj *Omake_array, *Kinitial_contents, *Osetf; extern Atom_id Svariable, Sstructure, Stype, Ssetf; extern Atom_id Smake_struct, Sstruct_access, Sstruct_store, Sstruct_type; extern LispObj *Omake_struct, *Ostruct_access, *Ostruct_store, *Ostruct_type; extern LispObj *Oparse_namestring, *Kerror, *Kabsolute, *Krelative, *Oopen, *Oclose, *Kif_does_not_exist; extern LispObj *Oequal_; extern LispFile *Stdout, *Stdin, *Stderr; #endif /* Lisp_internal_h */