qbit/xenocara
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
d95c5d8cd8
xenocara/app/xedit/lisp/internal.h

799 lines
24 KiB
C
Raw Normal View History

Importing from X.Org 7.2RC2
2006-11-25 13:07:29 -07:00
/* $XdotOrg: app/xedit/lisp/internal.h,v 1.3 2004/12/04 00:43:13 kuhn 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 <stdio.h>
#include "lisp/lisp.h"
#include "mp.h"
#include "re.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), 0)
#define LSTRING(str, size) LispNewString(str, size, 0)
/* string must be from the LispXXX allocation functions,
* and LispMused not yet called on it */
#define STRING2(str) LispNewString(str, strlen(str), 1)
#define LSTRING2(str, size) LispNewString(str, size, 1)
#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), 0)
#define STRINGSTREAM2(str, flag) \
LispNewStringStream(str, flag, strlen(str), 1)
#define LSTRINGSTREAM(str, flag, length) \
LispNewStringStream(str, flag, length, 0)
#define LSTRINGSTREAM2(str, flag, length) \
LispNewStringStream(str, flag, length, 1)
#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) LispGetAtomString(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->string
#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)
#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->string)
#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 char *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;
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(char*, int);
LispObj *LispNewFunction(LispObj*);
LispObj *LispNewFunctionQuote(LispObj*);
LispObj *LispNewStaticAtom(char*);
LispObj *LispNewDFloat(double);
LispObj *LispNewString(char*, long, int);
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(char*);
LispObj *LispNewPathname(LispObj*);
LispObj *LispNewStringStream(char*, int, long, int);
LispObj *LispNewFileStream(LispFile*, LispObj*, int);
LispObj *LispNewPipeStream(LispPipe*, LispObj*, int);
LispObj *LispNewBignum(mpi*);
LispObj *LispNewBigratio(mpr*);
LispAtom *LispGetAtom(char*);
/* This function does not allocate a copy of it's argument, but the argument
* itself. The argument string should never change. */
LispAtom *LispGetPermAtom(char*);
void *LispMalloc(size_t);
void *LispCalloc(size_t, size_t);
void *LispRealloc(void*, size_t);
char *LispStrdup(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(char *fmt, ...) PRINTF_FORMAT;
/* continuable error */
void LispContinuable(char *fmt, ...) PRINTF_FORMAT;
void LispMessage(char *fmt, ...) PRINTF_FORMAT;
void LispWarning(char *fmt, ...) PRINTF_FORMAT;
#undef PRINTF_FORMAT
LispObj *LispSetVariable(LispObj*, LispObj*, char*, int);
int LispRegisterOpaqueType(char*);
int LispPrintString(LispObj*, 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 */
Reference in New Issue Copy Permalink