cc.h

編譯器的辭法分析器工具

#ifndef CC_H
#define CC_H


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


/* standard clib */
#include <stdio.h>
#define p_gets(x) gets(x)
#define p_calloc(x,y) calloc((size_t)(x),(size_t)(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 ~3x line length, at least */
#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
                            /* 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;
extern TOKEN   *yybuffer;    /* yyoutput can be written here */

#ifndef BAD_ERROR        /* failed parse marked at deepest pt */
#define BAD_ERROR(x) fprintf(stderr,"(line %d) failed parse:\
 probable error near ..<>%s\nSkipping ...\n",yylineno,(char*)maxp);\
 while((yytchar!=EOF)&&get1token());get1token();\
 yylloc=NULL;
#endif

#ifndef ZER_ERROR        /* incomplete parse shows least remainder */
#define ZER_ERROR(x) fprintf(stderr,"(line %d) incomplete parse:\
 possible error near ..<>%s\nSkipping ...\n",yylineno,(char*)maxp);\
 while((yytchar!=EOF)&&get1token());get1token();\
 yylloc=NULL;
#endif

/* if p_entry is set, use that as handler, else print message. */

#ifndef BTK_ERROR        /* backtracking across a parse boundary */
#define BTK_ERROR(x) if (!p_entry){\
 fprintf(stderr,"(line %d) error:\
 parse backtracked across cut from point near <>%s\n\
",yylineno,(char*)maxp);}\
yylloc=NULL;\
longjmp(jmpb,1); /* should be to the ! we're backtracking across */
#endif


#ifndef ON_ERROR        /* default error mechanism */
#define ON_ERROR(x) switch(x){\
case  1:BAD_ERROR(1);break;\
case  0:ZER_ERROR(0);break;\
case -1:BTK_ERROR(-1);break;\
}
#endif


/* 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;*/ /* to track optimization */
}               FRAME;
typedef struct {
int     readbuffersize,
        maxprogramsize,
        stacksize,
	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
#define SUCCESS OK(1)
#define FAILURE KO(0)


/* input stream manipulations */

/* MARK has to be first line in a  routine.
 * The MARK saves the current parse frame.
 */

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

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

#define REWIND {\
fpop(p_frame);\
frestore(p_frame);\
}

/* RELEASE will destroy the temporary references */

# define RELEASE fpop(p_frame)

/*
 * 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 */\
                    *pstr=(TOKEN)yylex();\
                    lvbuff[(int)(pstr-buffer)]=yylval;\
		    maxp=pstr;\
                }
#else
#define MOVEON get1token()
#endif


/* 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 VALUE     *lvbuff;   /* the corresponding yylvals*/
extern VALUE     *plval;    /* and pointer */
extern INSTRUCTION *program;
extern int      pc;        /* program counter - counts up from 0 */
extern int      passcount;    /* count 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 for flying optimization */
extern jmp_buf  jmpb;
extern jmp_buf  p_jmpb;     /* or environments */
extern int      p_argc;     /* command line argument count */
extern char   **p_argv;     /* command line argument array */
extern PRECC_DATA precc_data;
extern int      msdos;
extern PARSER  *p_entry;    /* the current entry point */
extern int     p_enargs;
extern PARAM   p_eargv[];
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 */