home *** CD-ROM | disk | FTP | other *** search
/ The Education Master 1994 (4th Edition) / EDUCATIONS_MASTER_4TH_EDITION.bin / files / progmisc / qparser2 / cskels / skeldecl.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-07  |  11.8 KB  |  339 lines
  1. /*  (skel)decl.h
  2.  
  3.   QPARSER 4.0, QCAD Systems, Inc., San Jose, CA.
  4.   This code may be reproduced, modified, or built into third party software
  5. in any way deemed suitable by the purchaser of the QPARSER product.
  6.  
  7. General description:
  8.  
  9.   This skeleton file must be passed through lr1p with a suitable grammar
  10. file to generate a compilable C file, e.g. decls.h.
  11.   It and its companion C and skeleton-C files are guaranteed to compile,
  12. link and execute correctly under the Microsoft C or Unix compilation
  13. environment.  See the make file for your environment for more details:
  14.  
  15.   Microsoft:  m
  16.   Turbo:      makefile.mak
  17.   Unix:       makefile
  18.   Macintosh:  ???
  19.  
  20.   The compiler directive MSDOS, TCC, or UNIX is 
  21. required for the specific environment chosen.  Don't specify more than 
  22. one of these.
  23.   Other environments or compilers may require modifications to this
  24. source code.  Note that a modification to the skeleton and base C files
  25. will result in correct generated code for the new environment.
  26.  
  27.   */
  28.  
  29. #ifndef DECL_H
  30. #define DECL_H
  31.  
  32. #ifdef MSDOS
  33. #include <malloc.h>
  34. #endif
  35. #ifdef TCC
  36. #include <alloc.h>
  37. #endif
  38.  
  39. #ifndef SETSIZE
  40. #  include "sets.h"
  41. #endif
  42.  
  43. #define SHOWLINES 18   /* how many lines to put on a screen before 'more' */
  44.  
  45. #define HASHSIZE 167   /* number of symbol table hash buckets */
  46.  
  47. /*  definitions of base symbol table attributes.
  48.     Additional attributes may be added as desired -- but also extend
  49.     the corresponding array 'symtypenames' in skeltab.c, and
  50.     the 'dump_sym' function in skeldbug.c !!! */
  51. #define RESERVED 0     /*reserved token*/
  52. #define SYMERR 1       /*error recovery symbol*/
  53. #define USER 2         /*unknown default*/
  54. #define INTVAR 3       /*integer type*/
  55. #define REALVAR 4       /*real type*/
  56. #define STRVAR 5       /*string type*/
  57. #define CHART  6       /*character type*/
  58.  
  59. /*  The DEBUG_CHAR is a character which, when inserted in the
  60.     parser's source code, invokes Qparser debugging.
  61.     Debugging is enabled by compiling with -DDEBUG */
  62.  
  63. #define DEBUG_CHAR   '!'
  64.  
  65. typedef struct semrec_struct semrectype;
  66. typedef struct symtab_struct symtabtype;
  67.  
  68. extern symtabtype *symtab[HASHSIZE];
  69.  
  70. extern void inittables();  /* in qlex.c */
  71. extern int clevel;  /* symbol entry level number: -1 == reserved tokens */
  72.  
  73.   /* call this once before commencing with symbol table building */
  74. extern void init_sym();
  75.  
  76.   /* findsym: find a symbol.  Returns NULL if not in table */
  77. extern symtabtype *findsym( /* char *fsym */ );
  78.  
  79.  /* makesym returns a symbol entry if there; makes a new one if not.
  80.     Useful for FORTRAN-style variable declaration -- declare name
  81.     on first appearance, whether in a declaration or not.
  82.     syt: symbol type
  83.      */
  84. extern symtabtype *makesym( /* char *fsym; int syt */ );
  85.  
  86.   /* forcesym: forces a new symbol entry.  Use this for declarations
  87.     to cover a previous declaration with the same name. */
  88. extern symtabtype *forcesym( /* char *fsym; int syt */ );
  89.  
  90.   /* clearsym: sets the symbol table pointers to remove references to
  91.     everything at level >= clevel, assuming that level numbers
  92.     are monotonic.  Frees memory space. */
  93. extern void clearsym( /* int clevel */ );
  94.  
  95.   /* shows all the symbols in the symbol table*/
  96. extern void dump_all();
  97.  
  98. /* Semantics stuff */
  99.  
  100. #define STACKSIZE 100   /*maximum size of stack*/
  101.  
  102. extern int cstate;   /* TOS state -- not in stack! */
  103. extern int stack[];  /* array of other states */
  104. extern int stackx;   /* stack[stackx] is at the top of the stack */
  105. extern semrectype *semstack[];  /* semantics stack */
  106. extern int token,   /* current token number */
  107.            errpos,     /* position of current token in input line */
  108.            errors,
  109.            err_count;  /* if > 0, don't report syntax errors */
  110. extern semrectype *lsemp;   /* holds current semantics element */
  111. extern semrectype *lsempary[2];  /* holds current and 'next ' element */
  112.  
  113. /*Parser gen constants*/
  114. {##
  115.     var K, IDENT_TOKLEN, MAXFLAGLEN: integer;
  116.     begin
  117.       indent:=0;
  118.       ident_toklen:=15;
  119.       writeln('#define IDENT_TOKLEN ',ident_toklen);
  120.       if maxtoklen >ident_toklen then ident_toklen:=maxtoklen;
  121.       writeln('#define MAXTOKLEN ',ident_toklen);
  122.  
  123.       maxflaglen:= 9;   {the string length of "GENL_KIND", which counts as
  124.                          the longest predefined flag}
  125.       for k:=ldim(flags) to udim(flags) do
  126.         if maxflaglen < strlen(flags[k]) then
  127.           maxflaglen:=strlen(flags[k]);
  128.       writeln('#define MAXFLAGLEN ', maxflaglen);
  129.       writeln('#define MAXRPLEN ', maxrplen);
  130.              {length of longest production right member}
  131.       writeln('#define MAXNRPLEN ', maxnrplen);
  132.              {maximum nonterms in production right members}
  133.       writeln('#define TERM_TOKS ', term_toks);
  134.              { number of terminal tokens }
  135.       writeln('#define NTERM_TOKS ', nterm_toks);
  136.              { number of nonterminal tokens }
  137.       writeln('#define ALL_TOKS  ', term_toks+nterm_toks);
  138.              { all tokens }
  139.       writeln('#define IDENT_TOKX  ', id_tokx);
  140.              { token number of <identifier> }
  141.       writeln('#define INT_TOKX  ', int_tokx);
  142.              { token number of <integer> }
  143.       writeln('#define REAL_TOKX  ', real_tokx);
  144.              { token number of <real> }
  145.       writeln('#define STR_TOKX  ', str_tokx);
  146.              { token number of <string> }
  147.       writeln('#define CHAR_TOKX  ', char_tokx);
  148.              { token number of <character> }
  149.       writeln('#define STOP_TOKX  ', stop_tokx);
  150.              { token number of stopsign (end-of-file) }
  151.       writeln('#define GOAL_TOKX  ', goal_tokx);
  152.              { token number of goal }
  153.       writeln('#define EOL_TOKX  ', eol_tokx);
  154.              { token number of end-of-line }
  155.       writeln('#define REDUCELEN  ', reducestate);
  156.              { last reduce state }
  157.       writeln('#define READSTATE  ', readstate);
  158.              { first READ state }
  159.       writeln('#define LREADSTATE  ', lookstate-1);
  160.              { last READ state }
  161.       writeln('#define LOOKSTATE  ', lookstate);
  162.              { first LOOK state }
  163.       writeln('#define MAXSTATE  ', maxstate);
  164.              { largest state number }
  165.       writeln('#define RLTOKENS  ', udim(toknum));
  166.              { dimension of TOKNUM array }
  167.       writeln('#define SSTOKENS  ', udim(stk_state));
  168.              { dimension of ISTK_STATE array }
  169.       writeln('#define PRODTOKS  ', udim(prods));
  170.       writeln('#define TOKCHARS  ', term_chars
  171.                                      +nterm_chars
  172.                                      +all_toks);
  173.       writeln('#define START_STATE  ', start_state);
  174.              { initial state }
  175.       writeln('#define ISTK_STATE  ', istk_state);
  176.              { state initially pushed on stack }
  177.  
  178.       for k:=1 to term_toks do  {wild tokens}
  179.         if is_wild[k] then writeln('#define ', tokens[k], ' ', k);
  180.       end;
  181.    ##}
  182.  
  183. /* reserved flags used in SEMREC stuff */
  184. #define OTHER  0
  185. #define FIRST_SEMTYPE  OTHER
  186.  
  187. #define SEMERR 1
  188. #define IDENT  2
  189. #define FIXED  3
  190. #define FLOAT  4
  191. #define STRNG  5
  192. #define CHAR   6
  193. #define GENL_KIND 7
  194. /* add more special semantic flags as needed here */
  195. #define OFFSET  8     /* one plus the previous flag */
  196.  
  197. {##   var K: integer;
  198.       begin
  199.         indent:= 0;
  200.         writeln('#define FLAG_ARRAY_DIM (OFFSET+',
  201.                 udim(flags) - ldim(flags) + 1, ')');
  202.         writeln('/* Production flags */');
  203.         for k:=ldim(flags) to udim(flags) do
  204.           writeln('#define ', flags[k], ' (OFFSET+', k-ldim(flags), ')');
  205.         writeln('#define LAST_SEMTYPE (OFFSET+',
  206.                 udim(flags)-ldim(flags), ')');
  207.         end;  ##}
  208.  
  209. /* node tracing set used by QTREES */
  210. #define TSETSIZE  (SETSIZE(LAST_SEMTYPE+1))
  211. extern char trace_nodes[TSETSIZE];
  212.  
  213. /* new_sem: allocates and partially initializes a semrectype */
  214. extern semrectype *new_sem( /* int semt, symt */ );
  215.  
  216. /* these are standard definitions for Qtrees */
  217. #define POSITION(N) usem.position0[(N)-1]
  218. #define CHILD usem.position0[0]
  219. #define LEFT  usem.position0[0]
  220. #define RIGHT usem.position0[1]
  221. #define ONE   usem.position0[0]
  222. #define TWO   usem.position0[1]
  223. #define THREE usem.position0[2]
  224. #define FOUR  usem.position0[3]
  225. #define FIVE  usem.position0[4]
  226.  
  227. {## begin indent:=0;
  228.       if defined(skeldecl) then writeln(skeldecl); end; ##}
  229.  
  230. struct symtab_struct {
  231.    symtabtype *next;  /* linked list of symbols hashing to same bucket */
  232.    int level;    /* scope level: -1 is for reserved tokens, 0 global, etc.*/
  233.    char *sym;    /* the symbol referring to one of the following values */
  234.    int symt;  /* USER, INTVAR, REALVAR, etc. */
  235.    union {
  236.      int tokval;         /* RESERVED */
  237.      long int numval;    /* INTVAR, CHART */
  238.      double rval;        /* REALVAR */
  239.      char   *strx;       /* STRVAR */
  240.      /* +++ add customization here; also extend these:
  241.  
  242.             FILE              FUNCTION/VARIABLE
  243.             -----------------------------------
  244.             skeltab.c         symtypenames
  245.             skelsyms.c        new_sym, printf_sym, free_symtab_item
  246.             skeldbug.c        dump_sym
  247.  
  248.         --- */
  249. {## begin indent:=4;
  250.       if defined(symtab_union) then writeln(symtab_union); end; ##}
  251.      } usym;
  252.    };
  253.  
  254. struct semrec_struct {
  255.   int symt;  /* type definition of this node: USER, INTVAR, REALVAR,
  256.                     STRVAR, etc. */
  257.   int semt;  /* semantics type: IDENT, FIXED, etc. */
  258.   union {
  259.     symtabtype *symp;  /* IDENT */
  260.     long int numval;    /* FIXED, CHAR */
  261.     double rval;  /* FLOAT */
  262.     char *strx;   /* STRNG */
  263.     /* +++ add customization here --- */
  264. {## begin indent:=4;
  265.       if defined(semrec_union) then writeln(semrec_union); end; ##}
  266.     semrectype  *position0[MAXNRPLEN];  /* 0-based */
  267.     } usem;
  268.   };
  269.  
  270. /* the all-important apply function */
  271.  
  272. extern semrectype *apply( /* int cstate */ );
  273.  
  274. /* the parser tables; these are in skeltab.c  */
  275. extern short statex[];
  276. extern short map[];
  277. extern char  popno[];
  278. extern short toknum[];
  279. extern short tostate[];
  280. extern short stk_state[];
  281. extern short stk_tostate[];
  282. extern short psmx[];
  283. extern char  psmpos[];
  284. extern short prodx[];
  285. extern short prods[];
  286. extern short insym[];
  287. extern char  *tokstring[];
  288. extern char  *flags[];
  289.  
  290. extern int gen_debug;  /* TRUE to generate debugging tables */
  291.  
  292. /* following are used by lex.c */
  293.  
  294. extern int errors;
  295. extern void report_err(/* char *msg */ );
  296. extern void abort_trap(/* char *msg */ );
  297. extern void error(/* char *msg */ );
  298. extern void warn(/* char *msg */ );
  299. extern void symerror(/* char *sym, *msg */ );
  300.  
  301. /* returns 1 if OK, 0 if can't open file */
  302. extern int open_lex( /* char *filename */ );
  303.  
  304. extern void readline( /* char *line, int maxlen */ );
  305. extern int yesresp( /* char *msg */ );
  306. extern char resp( /* char *msg */ );
  307. extern int prompt_len;   /* 0 or 2, depending on sfile */
  308. extern void next_token();  /* return the 'next' token */
  309. extern void tokenread();   /* advance the read head */
  310. extern int tokenx, tokary[], skip_source;
  311. extern void show_lex();    /* display state of lexical analysis */
  312.  
  313. extern void close_lex();
  314.  
  315. /* This is the main parser function */
  316.  
  317. extern void parser();      /* Carries out a complete parse */
  318.  
  319. #if DEBUG == 1
  320. /* These are the debugging functions */
  321.  
  322. extern char resp();
  323. extern char *prodtrap;  /* NULL or set of productions to trap on */
  324. extern int debug_level,
  325.            trace_mode;
  326.  
  327. extern char *symtypenames[];
  328. extern void print_tree(semrectype *root);
  329. extern void idebug();
  330. extern void inspect_sem( /* int indent; semrectype *root */ );
  331. extern void inspect_stack( /* int *stack, int stackx, char kind */ );
  332. extern void dump_sym( /* symtabtype *root */ );
  333. extern void dump_sem( /* int indent; semrectype *root */ );
  334. extern void stk_dump(/* int kind, int *stack, int stackx, int debug_level */) ;
  335. #endif
  336.  
  337. #endif
  338.  
  339.