cc.h

編譯器的辭法分析器工具

#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);}

/* frame stack manipulation */
# define fpush(x) (*fptr++=(x))
# define fpop(x)  (x=*--fptr)
# define fpull(n) (fptr-=(n))
# define fsave(x) \
x.pstr=pstr;\
/*x.value=value;*/\
x.pc=pc;\
x.lineno=passcount
/*;\ ppeek(x.instr)*/
# define frestore(x) \
pstr=(x.lineno==passcount)?x.pstr:(btk_error(),buffer);\
pc=x.pc\
/*; value=x.value*/
/*; ppoke(x.instr)*/

/* 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 */
/* let's try some on-the-fly optimisation        */

/* Now let's disallow stack manipulations altogether !! */
#ifdef STACKMANIPS
#define pushMANIP(x)          if(0==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)=(TOKEN)(x)
#define popvalue(x)  (x=(*--value).val)
#define poptoken(x)  (x=(TOKEN)((*--value).val))
#define popparam(x)  (x=(*--value).par)
/*
 * # 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
 */
#define pullvalue(n) &((value-=(n))->val)
#define pullparam(n) &((value-=(n))->par)
#define pulltoken(n) (TOKEN)(&((value-=(n))->val))

#ifndef DOS
/* SUNUNIX versions */
#define setvalue(n)  pullvalue(call_mode?(n)-1:0);refvalue(1)
#define settoken(n)  pullvalue(call_mode?(n)-1:0);reftoken(1)
#define refvalue(n)  (value[(n)-2].val)
#define reftoken(n)  (TOKEN)(long)(value[(n)-2].val)
#define refpar(n)    (value[(n)-2].par)
#else
/* BORLAND versions */
#define setvalue(n)  ((pullvalue(call_mode?(n)-1:0))[-1].val)
#define settoken(n)  (TOKEN)((pullvalue(call_mode?(n)-1:0))[-1].val)
#define refvalue(n)  (value[(n)-2].val)
#define reftoken(n)  (TOKEN)(value[(n)-2].val)
#define refpar(n)    (value[(n)-2].par)
#endif

/* program-interpreter
 * in engine.c */
extern int      p_evaluate();

/* read and run parser, interpret resulting program
 * in engine.c */
extern ACTION   p_run;

/* parsers without actions */
/* defined in cc.c */
extern PARSER   p_andparse0;
extern PARSER   p_orparse0;
extern PARSER   p_many0;
extern PARSER   p_iter0;
extern PARSER   p_some0;
extern PARSER   p_option0;
extern PARSER   p_range0;
extern PARSER   p_hidden0;
extern PARSER   p_atch0;


/* defined in common.c */
extern PARSER   p_nothing0;
extern PARSER   p_anything0;
extern PARSER   p_first0;
extern PARSER   p_last0;
extern PARSER   p_exactly0;
extern PARSER   p_notexactly0;
extern PARSER   p_attach0;
extern PARSER   p_uerror0;

/* parsers with actions attached */
/* in cc.c */
extern PARSER   p_attach;
extern PARSER   p_prepend;
/* in common.c */
extern PARSER   p_andparse;
extern PARSER   p_orparse;
extern PARSER   p_nothing;
extern PARSER   p_option;
extern PARSER   p_many;
extern PARSER   p_some;
extern PARSER   p_anything;
extern PARSER   p_first;
extern PARSER   p_last;
extern PARSER   p_exactly;
extern PARSER   p_notexactly;
extern PARSER   p_range;


/* parsers taking a variable number of arguments */
extern STATUS   p_andparse0n(PARSER *,...);
extern STATUS   p_starparse0n(VALUE *,PARSER *,...);
extern STATUS   p_orparse0n (PARSER *,...);
extern STATUS   p_option0n  (PARSER *,...);
extern STATUS   p_hidden0n  (PARSER *,...);
extern STATUS   p_many0n    (PARSER *,...);
extern STATUS   p_iter0n    (int, PARSER *,...);
extern STATUS   p_some0n    (PARSER *,...);
extern STATUS   p_uniq0n    (PARSER *,...);
extern STATUS   p_attach0n  (PARSER *,...);
extern STATUS   p_prepend0n (PARSER *,...);
extern STATUS   p_range0n   (PREDICATE *,...);
extern STATUS   p_uerror0n  (PARSER *,...);
extern STATUS   p_until0n   (PARSER *,...);
extern PARSER   p_test0;

/* but replaced by macros here - args ignored */

#define p_andparse0n(p,a,q,b) p_andparse0(p,q)
#define p_orparse0n(p,a,q,b)  p_orparse0 (p,q)
#define p_option0n(p,a)       p_option0  (p)
#define p_hidden0n(p,a)       p_hidden0  (p)
#define p_many0n(p,a)         p_many0    (p)
#define p_iter0n(n,p,a)       p_iter0    (n,p)
#define p_some0n(p,a)         p_some0    (p)
#define p_uniq0n(p,a)         p_uniq0    (p)
#define p_attach0n(p,a,f,b)   p_attach   (p,f)
#define p_prepend0n(p,a,f,b)  p_prepend  (p,f)
#define p_range0n(p,a)        p_range0   (p)
#define p_uerror0n(p,a)       p_uerror0  (p)
#define p_until0n(p,a)        p_until0   (p)

/* actions */
/* in common.c */
extern ACTION   nop;

/* aux */
extern char     *p_scpy();
extern void     p_exit(int);
/* in engine.c */
extern TOKEN    get1token();
extern ACTION   realignbuffer;
extern VOID     callerror(int);
    /* (in on_error.c) */
extern ACTION   zer_error;
extern ACTION   bad_error;
extern ACTION   btk_error;
extern ACTION   precc_begin;
extern ACTION   precc_end;

#ifndef BEGIN
#define BEGIN
#endif
#ifndef END
#define END
#endif


#define P_PSTAR(X,CALL1,CALL2) \
  MARK;  p_tok = CALL1;\
  if (BADSTATUS(p_tok)) {RELEASE;return p_tok;}\
  X = (PARAM)INSTATUS(p_tok); /* decode */\
  p_tok = CALL2;\
  if (BADSTATUS(p_tok)) {REWIND;} else {RELEASE;}

#define P_PAND(CALL1,CALL2) \
  MARK; p_tok = CALL1;\
  if (BADSTATUS(p_tok)) {RELEASE;return p_tok;}\
  p_tok = CALL2;\
  if (BADSTATUS(p_tok)) {REWIND;} else {RELEASE;}




#define MAIN(x) \
int main(argc,argv)\
int argc; char **argv;\
{\
PARSER x;ACTION p_run;\
ACTION precc_free, precc_alloc, p_exit; int brk();\
if (msdos) brk((void*)C_STACKSIZE); /* set the C stack to 32K or whatever*/\
p_argc=argc;p_argv=argv;\
precc_alloc();                       /* set data as per params */\
p_run (x);\
precc_free();                       /* release memory, close files */\
p_exit(0);\
return 0;\
}\
 VOID  zer_error(){ON_ERROR(0);}\
 VOID  bad_error(){ON_ERROR(1);}\
 VOID  btk_error(){ON_ERROR(-1);}\
 VOID  precc_begin(){BEGIN;}\
 VOID  precc_end(){END;}\
 VOID  precc_alloc(){ACTION p_creat_data;\
 precc_data.readbuffersize=READBUFFERSIZE;\
 precc_data.maxprogramsize=MAXPROGRAMSIZE;\
 precc_data.stacksize=STACKSIZE;\
 precc_data.contextstacksize=CONTEXTSTACKSIZE;\
 precc_data.stacktokens=STACKTOKENS;\
 precc_data.oldattributes=OLDATTRIBUTES;\
 p_creat_data();}\
 VOID  precc_free(){\
 ACTION p_destr_data; static n;\
 if (!n++) p_destr_data();\
 }


#define V(n)  refvalue(n)   /* n'th argument */
#define T(n)  reftoken(n)   /* n'th argument */
#define VV(n) setvalue(n)   /* result from n args */
#define TT(n) settoken(n)   /*result of n args */

#endif