diff options
Diffstat (limited to 'lisp/bytecode.h')
| -rw-r--r-- | lisp/bytecode.h | 268 |
1 files changed, 268 insertions, 0 deletions
diff --git a/lisp/bytecode.h b/lisp/bytecode.h new file mode 100644 index 0000000..40d8444 --- /dev/null +++ b/lisp/bytecode.h @@ -0,0 +1,268 @@ +/* + * Copyright (c) 2002 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/bytecode.h,v 1.5 2002/11/23 08:26:48 paulo Exp $ */ + +#include "private.h" + +#ifndef Lisp_Bytecode_h +#define Lisp_Bytecode_h + +/* Number of arguments for &REST functions with no side effects, + * i.e. does not need to allocate new cells to build argument list. + * If this value is changed, it is also required to add more + * XBC_BCONS? opcodes and change ExecuteBytecode() */ +#define MAX_BCONS 8 + +typedef enum { + XBP_CONSP, + XBP_LISTP, + XBP_NUMBERP +} LispBytePredicate; + +typedef enum { + XBC_NOOP, + + XBC_INV, /* If NIL loaded, change to T else to NIL */ + XBC_NIL, /* Load NIL */ + XBC_T, /* Load T */ + + XBC_PRED, /* Preffix for predicate test */ + /* Followed by byte indicating test */ + + XBC_CAR, /* Set loaded value to it's car */ + XBC_CDR, /* Set loaded value to it's cdr */ + + XBC_CAR_SET, /* Set local variable to CAR or CDR of loaded value */ + XBC_CDR_SET, + /* Offset of local variable follows */ + + /* Sets C[AD]R of top of builtin stack with + * loaded value and pop builtin stack */ + XBC_RPLACA, + XBC_RPLACD, + + /* Push only one argument in builtin stack, and call directly + * LispObjectCompare without the need of pushing the second arguument */ + XBC_EQ, + XBC_EQL, + XBC_EQUAL, + XBC_EQUALP, + + XBC_LENGTH, + XBC_LAST, + XBC_NTHCDR, + + XBC_CAR_PUSH, /* Pushes CAR or CDR of loaded value to builtin stack */ + XBC_CDR_PUSH, + + XBC_PUSH, /* Push argument in builtin stack */ + XBC_PUSH_NIL, /* Pushes NIL in builtin stack */ + XBC_PUSH_UNSPEC, /* Pushes #<UNSPEC> in builtin stack */ + XBC_PUSH_T, /* Pushes T in builtin stack */ + XBC_PUSH_NIL_N, /* Pushes NIL in the builtin stack N times */ + XBC_PUSH_UNSPEC_N, /* Pushes #<UNSPEC> in the builtin stack N times */ + + + /* The builtin stack base is saved when entering the bytecode + * interpreter, and the bytecode does not reenter from builtin + * functions, yet, so there is no need, for XBC_BSAVE and + * XBC_BREST instructions */ + + XBC_LET, /* Push loaded value to stack */ + XBC_LETX, /* Push loaded value to stack and bind */ + /* Next byte(s) are the symbol offset */ + XBC_LET_NIL, /* Push loaded value to stack */ + XBC_LETX_NIL, /* Push loaded value to stack and bind */ + /* Next byte(s) are the symbol offset */ + + XBC_LETBIND, /* Bind locally added variables */ + /* Followed by number of symbols to bind */ + + XBC_UNLET, /* Unbind locally binded variables */ + /* Followed by number of symbols to unbind */ + + XBC_LOAD, /* Load argument already from the stack */ + /* Followed by offset follows the opcode */ + XBC_LOAD_LET, /* Load argument and push */ + XBC_LOAD_LETX, /* Load argument, push and bind */ + /* Followed by a short and the atom to be bound */ + XBC_LOAD_PUSH, + + XBC_LOADCON, /* Load a literal constant */ + /* Next bytes are the constant object */ + XBC_LOADCON_LET, /* Load a literal constant and push */ + XBC_LOADCON_LETX, /* Load a literal constant, push and bind */ + /* Followed by object constant and symbol to be bound */ + XBC_LOADCON_PUSH, + + /* Load CAR or CDR of local variable */ + XBC_LOAD_CAR, + XBC_LOAD_CDR, + + /* Change local variable value to it's CAR or CDR */ + XBC_LOAD_CAR_STORE, + XBC_LOAD_CDR_STORE, + + XBC_LOADCON_SET, + /* Followed by constant offset and local variable offset */ + + XBC_LOADSYM, /* Load object symbol value */ + /* The object atom pointer follows de opcode */ + XBC_LOADSYM_LET, /* Load object symbol value and push */ + XBC_LOADSYM_LETX, /* Load object symbol value, push and bind */ + /* The symbol atom name and bounded atom name to be bound follows */ + XBC_LOADSYM_PUSH, + + XBC_LOAD_SET, /* Set value of local variable to the value of another */ + /* Followed by two shorts */ + XBC_LOAD_CAR_SET, /* Like LOAD_SET, but apply CAR or CDR in the value */ + XBC_LOAD_CDR_SET, + + XBC_SET, /* Change value of local variable */ + /* A short integer with relative offset follows opcode */ + XBC_SETSYM, /* Change value of symbol */ + /* The atom symbol pointer follows opcode */ + + XBC_SET_NIL, /* Like XBC_SET but sets the local variable to NIL */ + + XBC_CALL, /* Call builtin function */ + /* 1 byte follows telling how many arguments to use */ + /* LispBuiltin pointer follows opcode */ + + XBC_CALL_SET, + /* Like BCALL, but also followed by an short index of local variable */ + + XBC_BYTECALL, /* Call bytecode */ + /* 1 byte for number of arguments */ + /* 1 byte for index in bytecode table */ + + XBC_FUNCALL, + /* Opcode followed by function and arguments objects, to + * be evaluated at run time, as it was not resolved at + * bytecode generation time (or is not implemented in + * the bytecode compiler) */ + + + XBC_LETREC, /* Recursive function call */ + /* 1 byte follows telling how many arguments the funtion receives */ + + /* Helper for math functions. Uses a preallocated CONS, + * setting it's CAR to the loaded value, and in the same step + * pushes the CONS to the builtin stack */ + XBC_BCONS, + /* Like BCONS but it is a list of 2 arguments, first argument + * is saved on the stack, replace with list of 2 arguments */ + XBC_BCONS1, + /* Like BCONS1 but it is a list of 3 arguments, first arguments + * are saved on the stack, replace with list of first stack + * argument with list or 3 arguments, and pop stack */ + XBC_BCONS2, + XBC_BCONS3, + XBC_BCONS4, + XBC_BCONS5, + XBC_BCONS6, + XBC_BCONS7, + + /* Build a CONS */ + XBC_CCONS, /* Make CONS of two constants */ + /* Constants follow opcode */ + XBC_CSTAR, /* Save the CAR of the CONS */ + XBC_CFINI, /* Loaded value is the CDR */ + + /* These are to help in interactively building lists */ + XBC_LSTAR, /* Start building a list in the gc protected stack */ + XBC_LCONS, /* Add loaded object to list */ + XBC_LFINI, /* List is finished */ + + /* Inconditional jumps */ + XBC_JUMP, /* Jump relative to following signed int */ + + /* Conditional jumps, if true */ + XBC_JUMPT, /* Jump relative to following signed int */ + + /* Conditional jumps, if false */ + XBC_JUMPNIL, /* Jump relative to following signed int */ + + /* Structure field access and type check */ + XBC_STRUCT, + XBC_STRUCTP, + + XBC_RETURN /* Resume bytecode execution */ +} LispByteOpcode; + + +struct _LispBytecode { + unsigned char *code; /* Bytecode data */ + long length; /* length of bytecode stream */ +}; + +/* + * Prototypes + */ +void LispBytecodeInit(void); + +LispObj *Lisp_Compile(LispBuiltin*); +LispObj *Lisp_Disassemble(LispBuiltin*); + +LispObj *LispCompileForm(LispObj*); +LispObj *LispExecuteBytecode(LispObj*); + +void Com_And(LispCom*, LispBuiltin*); +void Com_Block(LispCom*, LispBuiltin*); +void Com_C_r(LispCom*, LispBuiltin*); +void Com_Cond(LispCom*, LispBuiltin*); +void Com_Cons(LispCom*, LispBuiltin*); +void Com_Consp(LispCom*, LispBuiltin*); +void Com_Dolist(LispCom*, LispBuiltin*); +void Com_Eq(LispCom*, LispBuiltin*); +void Com_Go(LispCom*, LispBuiltin*); +void Com_If(LispCom*, LispBuiltin*); +void Com_Last(LispCom*, LispBuiltin*); +void Com_Length(LispCom*, LispBuiltin*); +void Com_Let(LispCom*, LispBuiltin*); +void Com_Letx(LispCom*, LispBuiltin*); +void Com_Listp(LispCom*, LispBuiltin*); +void Com_Loop(LispCom*, LispBuiltin*); +void Com_Nthcdr(LispCom*, LispBuiltin*); +void Com_Null(LispCom*, LispBuiltin*); +void Com_Numberp(LispCom*, LispBuiltin*); +void Com_Or(LispCom*, LispBuiltin*); +void Com_Progn(LispCom*, LispBuiltin*); +void Com_Return(LispCom*, LispBuiltin*); +void Com_ReturnFrom(LispCom*, LispBuiltin*); +void Com_Rplac_(LispCom*, LispBuiltin*); +void Com_Setq(LispCom*, LispBuiltin*); +void Com_Tagbody(LispCom*, LispBuiltin*); +void Com_Unless(LispCom*, LispBuiltin*); +void Com_Until(LispCom*, LispBuiltin*); +void Com_When(LispCom*, LispBuiltin*); +void Com_While(LispCom*, LispBuiltin*); + +#endif /* Lisp_Bytecode_h */ |