mal_instruction.h

一个内存数据库的源代码这是服务器端还有客户端

#ifndef _MAL_INSTR_H
#define _MAL_INSTR_H

#include "mal_type.h"
#include "mal_stack.h"
#include "mal_properties.h"

#define isaSignature(P)  ((P)->token >=COMMANDsymbol)

#ifdef MALprofiler
#ifdef HAVE_SYS_TIMES_H
# include <sys/times.h>
#endif
#endif

#define DEBUG_MAL_INSTR
#define MAXARG 9
#define STMT_INCREMENT 32
#define STMT_MAXIMUM  1<<16
#define MAXVARS 32

typedef struct SYMDEF {
	struct SYMDEF *peer;	/* where to look next */
	struct SYMDEF *skip;	/* skip to next different symbol */
	str name;
	int kind;
	struct MALBLK *def;	/* the details of the MAL fcn */
} *Symbol, SymRecord;

typedef struct VARRECORD {
	str name;		/* argname or lexical value repr */
	malType type;		/* internal type signature */
	int gdktype;		/* for backend */
	bit isaconstant;	/* value cannot change */
	bit isatypevar;		/* denotes a type variable */
	bit fixtype;		/* the type has been fixed */
	bit isudftype;		/* type defined in program */
	bit cleanup;		/* remove upon function return */
	bit isused;		/* in-out argument to function */
	int tmpindex;		/* temporary variable */
	short scope;		/* block id where it is declared */
	short depth;		/* ... depth in nesting */
	short beginLifespan, endLifespan, lastUpdate;	/* for optimizers */
	PropertySet props;	/* private list of (name,value) pairs */
	ValRecord value;
} *VarPtr, VarRecord;

/* type check status is kept around to improve type checking efficiency */
#define TYPE_ERROR      -1
#define TYPE_UNKNOWN            0
#define TYPE_DYNAMIC            1
#define TYPE_BIND           2
#define TYPE_RESOLVED              4

#define QUICKCLEANUP 1
#define GARBAGECONTROL 2

#define VARARGS 1	/* deal with variable arguments */
#define VARRETS 2

/* all functions return a string */
typedef str (*MALfcn) ();

typedef struct {
	bit token;		/* instruction type */
	bit barrier;		/* flow of control modifier takes:
				   BARRIER, LEAVE, REDO, EXIT, CATCH, RAISE*/
	bit typechk;		/* type check status */
	bit gc;			/* garbage control flags */
	bit polymorphic;	/* complex type analysis */
	bit varargs;		/* variable number of arguments or targets */
	MALfcn fcn;		/* resolved function address */
	struct MALBLK *blk;	/* resolved MAL function address */
	int jump;		/* controlflow program counter */


	str modname;		/* module context */
	str fcnname;		/* function name */
	short argc, retc, maxarg;	/* total and result argument count */
	short argv[1];		/* at least one entry */
} *InstrPtr, InstrRecord;



typedef struct PERF {
#ifdef HAVE_TIMES
	struct tms timer;	/* timing information */
#endif
	time_t clock;		/* clock */
	lng clk;		/* microseconds clock */
	long counter;
	long ticks;		/* micro seconds spent */
	bit trace;		/* facilitate filter-based profiling */
} *ProfPtr, ProfRecord;

typedef struct MALBLK {
	str binding;		/* related C-function */
	str help;		/* supportive commentary */
	PropertySet props;	/* private */
	struct MALBLK *alternative;
	int vtop;		/* next free slot */
	int vsize;		/* size of variable arena */
	VarRecord **var;	/* Variable table */
	int stop;		/* next free slot */
	int ssize;		/* byte size of arena */
	InstrPtr *stmt;		/* Instruction location */
	int errors;		/* left over errors */
	int typefixed;		/* no undetermined instruction */
	int flowfixed;		/* all flow instructions are fixed */
	ProfPtr profiler;
	struct MALBLK *history;/* of optimizer actions */
} *MalBlkPtr, MalBlkRecord;



#define getModuleId(P)     (P)->modname
#define setModuleId(P,S)    (P)->modname= S
#define setModuleScope(P,S) {(P)->modname= (S)==NULL?NULL: (S)->name;}

#define getFunctionId(P)       (P)->fcnname
#define setFunctionId(P,S)  (P)->fcnname= S
#define garbageControl(P)   ((P)->gc & GARBAGECONTROL)
#define needsCleanup(P)   ((P)->gc & QUICKCLEANUP)

#define getInstrPtr(M,I)    (M)->stmt[I]
#define getSignature(S)     getInstrPtr((S)->def,0)
#define getFcnName(M)       getFunctionId(getInstrPtr(M,0))
#define getArgCount(M)      getInstrPtr(M,0)->argc
#define getModName(M)       getModuleId(getInstrPtr(M,0))
#define getPrgSize(M)       (M)->stop

#define getVar(M,I)     (M)->var[I]
#define getVarTmp(M,I)      (M)->var[I]->tmpindex
#define isConstant(M,I) ((M)->var[I]->isaconstant)
#define isTypeVar(M,I)  ((M)->var[I]->isatypevar)
#define isTmpVar(M,I)   (!(M)->var[I]->name || *(M)->var[I]->name == TMPMARKER)
#define getVarScope(M,I)   ((M)->var[I]->scope)
#define getVarProperties(M,I)   ((M)->var[I]->props)

#define getVarDepth(M,I)   ((M)->var[I]->depth)
#define isFixed(M,I)        ((M)->var[I]->fixtype)
#define freezeVarType(M,I) getVar(M,I)->isudftype = 1;
#define setFixed(M,I)       ((M)->var[I]->fixtype= 1)
#define setVarCleanup(M,I)     ((M)->var[I]->cleanup)
#define isVarGarbage(M,I)     ((M)->var[I]->cleanup)
#define setVarUsed(M,I,V)		((M)->var[I]->isused= V)
#define isVarUsed(M,I)		((M)->var[I]->isused)
#define getVarConstant(M,I)     ((M)->var[I]->value)
#define getVarType(M,I)     ((M)->var[I]->type)
#define getVarGDKType(M,I)      ((M)->var[I]->gdktype)

#define getLastUpdate(M,I)	((M)->var[I]->lastUpdate)
#define getEndLifespan(M,I)	((M)->var[I]->endLifespan)
#define getBeginLifespan(M,I)	((M)->var[I]->beginLifespan)

#define getDestVar(P)   (P)->argv[0]
#define setDestVar(P,X)   (P)->argv[0]  =X
#define setDestType(M,P,V)  setVarType((M),getDestVar(P),V)
#define getDestType(M,P)    destinationType((M),(P))
#define getArg(P,I) (P)->argv[I]
#define setArg(P,I,R) (P)->argv[I]= R
#define getArgName(M,P,I)   getVarName((M),(P)->argv[I])
#define getArgType(M,P,I)   getVarType((M),(P)->argv[I])

mal_export InstrPtr newInstruction(MalBlkPtr mb, int kind);
mal_export InstrPtr copyInstruction(InstrPtr p);
mal_export void oldmoveInstruction(InstrPtr dst, InstrPtr src);
mal_export void clrInstruction(InstrPtr p);
mal_export void freeInstruction(InstrPtr p);
mal_export void clrFunction(InstrPtr p);
mal_export Symbol newSymbol(str nme, int kind);
mal_export void freeSymbol(Symbol s);
mal_export void freeSymbolList(Symbol s);
mal_export void printSignature(stream *fd, Symbol s, int flg);

mal_export MalBlkPtr newMalBlk(int maxvars, int maxstmts);
mal_export void resetMalBlk(MalBlkPtr mb, int stop);
mal_export void newMalBlkStmt(MalBlkPtr mb, int maxstmts);
mal_export void prepareMalBlk(MalBlkPtr mb, str s);
mal_export void freeMalBlk(MalBlkPtr mb);
mal_export MalBlkPtr copyMalBlk(MalBlkPtr);
mal_export void addtoMalBlkHistory(MalBlkPtr mb);
mal_export void showMalBlkHistory(MalBlkPtr mb);
mal_export MalBlkPtr getMalBlkHistory(MalBlkPtr mb,int idx);
mal_export void expandMalBlk(MalBlkPtr mb, int lines);
mal_export void trimMalBlk(MalBlkPtr mb);
mal_export void moveInstruction(MalBlkPtr mb, int pc, int target);
mal_export void insertInstruction(MalBlkPtr mb, InstrPtr p, int pc);
mal_export void removeInstruction(MalBlkPtr mb, InstrPtr p);
mal_export void removeInstructionBlock(MalBlkPtr mb, int pc, int cnt);
mal_export str operatorName(int i);

mal_export int findVariable(MalBlkPtr mb, str name);
mal_export int findTmpVariable(MalBlkPtr mb, int type);
mal_export int findVariableLength(MalBlkPtr mb, str name, int len);
mal_export malType getType(MalBlkPtr mb, str nme);
mal_export str getArgDefault(MalBlkPtr mb, InstrPtr p, int idx);
mal_export str getVarName(MalBlkPtr mb, int i);
mal_export str getRefName(MalBlkPtr mb, int i);
mal_export int newVariable(MalBlkPtr mb, str name, malType type);
mal_export void renameVariable(MalBlkPtr mb, int i, str name);
mal_export void copyVariable(MalBlkPtr dst, MalBlkPtr src, VarPtr v);
mal_export void removeVariable(MalBlkPtr mb, int varid);
mal_export int newTmpVariable(MalBlkPtr mb, malType type);
mal_export int newTmpSink(MalBlkPtr mb, malType type);
mal_export int newTypeVariable(MalBlkPtr mb, malType type);
mal_export void delVariable(MalBlkPtr mb, int varid);
mal_export void freeVariable(MalBlkPtr mb, int varid);
mal_export void clearVariable(MalBlkPtr mb, int varid);
mal_export int cpyConstant(MalBlkPtr mb, VarPtr vr);
mal_export int defConstant(MalBlkPtr mb, int type, ValPtr cst);
mal_export int fndConstant(MalBlkPtr mb, ValPtr cst);
mal_export int convertConstant(malType type, ValPtr vr);

mal_export void pushInstruction(MalBlkPtr mb, InstrPtr p);
mal_export InstrPtr pushArgument(MalBlkPtr mb, InstrPtr p, int varid);
mal_export InstrPtr setArgument(MalBlkPtr mb, InstrPtr p, int idx, int varid);
mal_export InstrPtr pushReturn(MalBlkPtr mb, InstrPtr p, int varid);
mal_export InstrPtr pushArgumentId(MalBlkPtr mb, InstrPtr p, str name);
mal_export void delArgument(InstrPtr p, int varid);
mal_export void setVarType(MalBlkPtr mb, int i, int tpe);
mal_export void clrAllTypes(MalBlkPtr mb);
mal_export void setArgType(MalBlkPtr mb, InstrPtr p, int i, int tpe);
mal_export void setReturnArgument(InstrPtr p, int varid);
mal_export malType destinationType(MalBlkPtr mb, InstrPtr p);
mal_export void setPolymorphic(InstrPtr p, int tpe, int force);
mal_export void setVarProperty(MalBlkPtr mb, int i, str name, str op, ValPtr cst);
mal_export str fcnClass(InstrPtr p);
mal_export str fcnDefinition(MalBlkPtr mb, InstrPtr p, str s, int flg);
mal_export void printInstruction(stream *fd, MalBlkPtr mb, InstrPtr p, int flg);
mal_export str recognizedCall(MalBlkPtr mb, InstrPtr p, str s);
mal_export void promptInstruction(stream *fd, MalBlkPtr mb, InstrPtr p, int flg);
mal_export str instruction2str(MalBlkPtr mb, InstrPtr p, int hidden);
mal_export str function2str(MalBlkPtr mb, int flg);
mal_export void pushEndInstruction(MalBlkPtr mb);	/* used in src/mal/mal_parser.c */
/* Utility macros to inspect an instruction */
#define functionStart(X) ((X)->token == FUNCTIONsymbol || \
              (X)->token == COMMANDsymbol || \
              (X)->token == FACTORYsymbol )
#define functionExit(X)  ((X)->token == ENDsymbol)

#define blockStart(X)   ((X)->barrier && (((X)->barrier == BARRIERsymbol || \
             (X)->barrier == CATCHsymbol )))
#define blockExit(X) (X)->barrier == EXITsymbol
#define blockCntrl(X) ( (X)->barrier== LEAVEsymbol ||  \
             (X)->barrier== REDOsymbol || (X)->barrier== RETURNsymbol )

mal_export void strBeforeCall(ValPtr v, ValPtr bak);
mal_export void strAfterCall(ValPtr v, ValPtr bak);
mal_export void batBeforeCall(ValPtr v, ValPtr bak);
mal_export void batAfterCall(ValPtr v, ValPtr bak);
#endif /*  _MAL_INSTR_H */