ccx.h

編譯器的辭法分析器工具

# ifndef CC_H
# define CC_H

# ifdef __MSDOS__
# define p_memleft()  coreleft()
# else
# define p_memleft()  32000
# endif


/* standard clib */                     /* p_gets is undefined, so set  */
# include <stdio.h>                     /* it to gets, which is.        */
# define p_gets(x) gets(x)
# define p_calloc(x,y)  calloc((long)(x),(long)(y))
# define p_free(x)    free((VOID *)(x))
# include <stdarg.h>
# include <string.h>
# include <setjmp.h>


/* default defs */
# ifndef VALUE
# define VALUE char *        /* make sure you define VALUE !! */
# endif
# ifndef TOKEN
# define TOKEN char            /* and TOKEN, if not int and char */
# endif
# ifndef PARAM
# define PARAM long         /* VALUE=synthetic, PARAM=inherited */
# endif
# ifndef MAXPROGRAMSIZE
# define MAXPROGRAMSIZE 4096 /* 20K (chars) is often too big in DOS*/
# endif                     /* but this is proportional to line length */
# ifndef READBUFFERSIZE
# define READBUFFERSIZE 2048 /* ditto */
# endif                     /* because this IS the line length */
# ifndef STACKSIZE
# define STACKSIZE 1        /* NOT NEEDED ANY MORE UNLESS OLD STYLE VV(n) */
# endif                     /* ATTRIBUTE REFS ARE BEING SUPPORTED */
                            /* If set, it is very difficult to overun 2K ! */

                            /* msdos defns */
# ifndef CONTEXTSTACKSIZE
# define CONTEXTSTACKSIZE 1024
# endif
# ifndef C_STACKSIZE       
# define C_STACKSIZE 0x7FFF
# endif                     /* expect to need as large a stack as possible */

                            /* compatibility */
# ifndef STACKTOKENS
# define STACKTOKENS 0      /* Don't put tokens on the attribute stack */
# endif                     /* unless you are sure there is one! */
# ifndef OLDATTRIBUTES
# define OLDATTRIBUTES 0    /* Don't generate code which supports $1, $2, ... */
# endif                     /* (The $named attr. refs. are supported anyway) */

# define MAXARGS 16         /* number of params catered for */
                            /* DON'T change it! */

extern  int        yytchar;            /* the last thing yylex saw     */
extern  int        yylineno;        /* line count */
/* I'll put in the decls for the yystuff here, in case they're needed */
extern  int        yylen;
extern  int        yylex();
extern  char      *yylloc;
extern  VALUE      yylval;


/* local defs */
# define OPCODE char
# define VOID void

/* typedefs */
typedef PARAM status;            /* STATUS is returned by a PARSER */
# define STATUS status

typedef STATUS  PARSER();        /* PARSER returns a STATUS */
# define TOPARSER *(PARSER*)
# define TOVALUE (VALUE)
typedef VOID    ACTION();        /* VALUE stack manipulation */
typedef int boolean;            /* BOOLEAN is returned by a PREDICATE */
# define BOOLEAN boolean
typedef BOOLEAN PREDICATE();    /* PREDICATE returns a BOOLEAN */

typedef struct {            /* an INSTRUCTION consists of ... */
    OPCODE  opcode;            /* an OPCODE as opcode and ... */
    union {                /* an ACTION or  ... */
            ACTION  *act;    /* a literal as operand. */
            TOKEN   tok;        /* The opcode selects the */
        VALUE   val;
        PARAM   par;
        } operand;             /* interpretation of the operand. */
}       INSTRUCTION;
typedef union {                /* The VALUE stack actually contains */
           VALUE val;        /* STACKVALUES, which may be either */
        TOKEN tok;        /* VALUEs or TOKENs. TOKENs are */
        PARAM par;        /* ... */
        } STACKVALUE;            /* pushed when literals are hit. */
typedef struct{             /* all the info required for a REWIND */
        TOKEN     *pstr;
        STACKVALUE *value;
        int pc;
        int lineno;
        /* INSTRUCTION instr;*/ /* will introduce for optimization */
        } FRAME;
typedef struct {
int     readbuffersize,      /* READBUFFERSIZE */
        maxprogramsize,      /* MAXPROGRAMSIZE */
        stacksize,           /* STACKSIZE */
        contextstacksize,    /* CONTEXTSTACKSIZE */
        stacktokens,         /* (boolean) support tokens as attrs for old code*/
        oldattributes;       /* (boolean) generate yacc style attr. refs */
}       PRECC_DATA;


/* instruction destructors and constructors */
# define Action(x) ((x).operand.act)
# define Token(x)  ((x).operand.tok)
# define Param(x)  ((x).operand.par)
# define Opcode(x) ((x).opcode)
# define Value(x)  ((x).operand.val)

/* status macros */
# define BADSTATUS(x)  (!(x))        /* BADSTATUS(x) is a PREDICATE */
# define GOODSTATUS(x) (x)           /* as is GOODSTATUS(x) */
# define INSTATUS(x) ( (PARAM) ( (long)(x) - ( (0>(int)(x)) ? 0 : 1 ) ) )
                                     /* success deconstructor */
# define OK(x) ( (STATUS) ( ( (0>(int)(x)) ? 0 : 1 ) + (long)(x) ) )
                                     /* success constructor */
# define KO(x) 0                     /* failure constructor */
# define SUCCESS OK(1)
# define FAILURE KO(0)


/* input stream manipulations */
                    /* MARK has to be first line in a */
                    /* routine. 'string' is a reserved */
                    /* local variable, as is 'count'. */
                    /* The MARK sets string and count to */
                    /* the current parse point and pc. */

#define MARK {\
fsave(p_frame);\
fpush(p_frame);\
}

                    /* REWIND resets the parse point and */
                    /* to the MARK at the head of the fn.*/
                    /* provided that a new line hasn't   */
                    /* already been read, in which case  */
                    /* just go back as far as possible */

#define REWIND {\
fpop(p_frame);\
frestore(p_frame);\
}
                    /* MOVEON budges the high-water mark */
                    /* maxp up to the current parse pt. */

/* 
 * maxp+1 is the first address I have not yet written into. The TOKEN
 * space should be occupied by a 0. maxp is the last position  I have
 * written into.
 *
 * pstr is the current TOKEN position. Notice that I am going to have to
 * read one TOKEN into *pstr to start up?
 *
 * We start with pstr=maxp=&buffer, and *buffer=first token.
 */

#ifdef OLDSTYLEMOVEON
#define MOVEON if(++pstr>maxp){  /* this next space not written into yet*/\
                    *pstr=(TOKEN)yylex();\
                    lvbuff[(int)(pstr-buffer)]=yylval;\
                    maxp=pstr;\
                }
#else
#define MOVEON get1token()
#endif


/* RELEASE destroys the frame */

# define RELEASE fpop(p_frame)

/* the secret parse string and stacks */
extern TOKEN     *pstr;         /* parsed stream */
extern TOKEN     *maxp;         /* maximal parse point in stream */
extern TOKEN     *buffer;       /* where the pstr points to */
extern TOKEN     *yybuffer;     /* points to the buffer */
extern VALUE     *lvbuff; /* corresponding yylvals */
extern VALUE     *plval;        /* and pointer */
extern INSTRUCTION *program;
extern int pc;                  /* program counter - counts up from 0 */
extern int passcount;           /* number of cuts */
extern STACKVALUE  *stack;      /* the evaluation stack - either VALUEs
                       or TOKENs */
extern STACKVALUE  *value;      /* top of evaluation stack */
extern FRAME     *fstack;       /* top of frame stack ... */
extern FRAME     *fptr;         /* and pointer. */
extern FRAME      p_frame;      /* a frame cache */
extern INSTRUCTION instr;       /* single instruction cache */
extern int call_mode;           /* 0 for auto-calling convention, 1=manual */
extern int optimize;            /* 1 = flying program optimization */
extern jmp_buf jmpb;            /* environment       */
extern jmp_buf p_jmpb;          /* or environments   */
extern int p_argc;              /* main() arg count  */
extern char **p_argv;           /* main() arg vector */
extern PRECC_DATA precc_data;   /* all command line parameters kept here */
extern int msdos;
extern PARSER *p_entry;
extern int     p_enargs;
extern PARAM   p_eargv[MAXARGS];
extern char   *p_infile,        /* stdin name (eventually "-" if not a file) */
              *p_outfile;       /* stdout name (eventually "-" if not a file) */


/* opcodes */
# define INCR   5            /* increment value stack */
# define PARM   4            /* parameter to a function call */
# define FUNC   3            /* That's got an ACTION operand */
# define EXIT   2
# define CNST   1            /* That's got a VALUE operand. */
# define NOP    0            /* Saves time. */

/* program stack manipulation */
#define push(x) {if(pc>=precc_data.maxprogramsize-1){\
                 fprintf(stderr,"precc: program stack overflow (%d)\n",pc);\
                 p_exit(1);\
                 }\
                 program[pc++]=(x);\
                }
# define pull(n) (pc-=(n))
# define pop(x)  (x=program[--pc])
# define ppeek(x) (pc>0?x=program[pc-1]:((x).opcode=EXIT,(x)))
# define ppoke(x) {if(pc>0)program[pc-1]=(x);}

/* load and unlaod the current instruction */
#define getinstruction(n,x)   {Opcode(instr)=(n);Action(instr)=(x);}
#define pushinstruction(n,x)  {getinstruction(n,x);push(instr);}
#define getTOKEN(x)           {Opcode(instr)=(CNST);Token(instr)=(TOKEN)(x);}
#define getPARAM(x)           {Opcode(instr)=(PARM);Param(instr)=(PARAM)(x);}
#define getMANIP(x)           {Opcode(instr)=(INCR);Param(instr)=(PARAM)(x);}
#define getVALUE(x)           {Opcode(instr)=(CNST);Value(instr)=(VALUE)(x);}
#define pushTOKEN(x)          {getTOKEN(x);push(instr);}
#define pushPARAM(x)          {getPARAM(x);push(instr);}
#define pushVALUE(x)          {getVALUE(x);push(instr);}
#define pushACTION(x)         pushinstruction(FUNC,(x))
#define pushEXIT              pushinstruction(EXIT,0)
/* don't allow extra stack manips if call_mode=1 */
/* and let's try some on-the-fly optimisation    */
/* now let's try disabling stack manipulations altogether ! */
#ifdef STACKMANIPS
#define pushMANIP(x)          if(!call_mode){\
                               if(optimize&&(Opcode(ppeek(instr))==(INCR))){\
                                   Param(instr) += (PARAM)(x);\
                                   ppoke(instr);\
                               } else{\
                                   getMANIP(x);\
                                   push(instr);\
                               }\
                              }
#else
# define pushMANIP(x)
#endif
# define pushINCR               pushMANIP(1)
# define pushDECR               pushMANIP(-1)
# define pushNOP               pushinstruction(NOP,0)

/* evaluation stack manipulation */
# define pushvalue(x) ((*value++).val)=(x)
# define pushparam(x) ((*value++).par)=(x)
# define pushtoken(x) ((*value++).val)=(VALUE)(x)
# define popvalue(x)  (x=(*--value).val)
# define poptoken(x)  (x=(TOKEN)(*--value).val)
# define popparam(x)  (x=(*--value).par)
# define pullvalue(n) &((value-=(n))->val)
# define pullparam(n) &((value-=(n))->par)
# define pulltoken(n) &(TOKEN)((value-=(n))->val))
/*
# define pullvalue(n) &stack[(int)(value-=(n))-(int)stack].val
# define pullparam(n) &stack[(int)(value-=(n))-(int)stack].par
# define pulltoken(n) &stack[(int)(value-=(n))-(int)stack].tok
*/

/* frame stack manipulation */
# define fpush(x) (*fptr++=(x))