Initial revision

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 */