开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
err.h
资源名称：pccts133.zip　[点击查看]
上传用户：itx_2006
上传日期：2007-01-06
资源大小：493k
文件大小：26k
源码类别：

编译器/解释器

开发平台：

Others

err.h：源码内容
  1. /*
  2.  * err.h
  3.  *
  4.  * Standard error handling mechanism
  5.  *
  6.  * SOFTWARE RIGHTS
  7.  *
  8.  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
  9.  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
  10.  * company may do whatever they wish with source code distributed with
  11.  * PCCTS or the code generated by PCCTS, including the incorporation of
  12.  * PCCTS, or its output, into commerical software.
  13.  *
  14.  * We encourage users to develop software with PCCTS.  However, we do ask
  15.  * that credit is given to us for developing PCCTS.  By "credit",
  16.  * we mean that if you incorporate our source code into one of your
  17.  * programs (commercial product, research project, or otherwise) that you
  18.  * acknowledge this fact somewhere in the documentation, research report,
  19.  * etc...  If you like PCCTS and have developed a nice tool with the
  20.  * output, please mention that you developed it using PCCTS.  In
  21.  * addition, we ask that this header remain intact in our source code.
  22.  * As long as these guidelines are kept, we expect to continue enhancing
  23.  * this system and expect to make other tools available as they are
  24.  * completed.
  25.  *
  26.  * Has grown to hold all kinds of stuff (err.h is increasingly misnamed)
  27.  *
  28.  * ANTLR 1.33
  29.  * Terence Parr
  30.  * Parr Research Corporation
  31.  * with Purdue University and AHPCRC, University of Minnesota
  32.  * 1989-1998
  33.  */
  35. #ifndef ERR_H
  36. #define ERR_H
  38. #include "pcctscfg.h"
  40. /*       */
  41. /*  7-Apr-97  133MR1       */
  42. /* Proper choice of STDC and cplusplus pre-processor symbols (?) */
  43. /*       */
  44. #include PCCTS_STRING_H
  45. #ifdef __STDC__
  46. #include <stdarg.h>
  47. #endif
  48. #ifdef __cplusplus
  49. #include PCCTS_STDARG_H
  50. #endif
  51. #ifndef __STDC__
  52. #ifndef __cplusplus
  53. #include <varargs.h>
  54. #endif
  55. #endif
  57. #ifdef DUM
  58. /* Define usable bits per unsigned int word (used for set stuff) */
  59. #ifdef PC
  60. #define BSETWORDSIZE 16
  61. #define BSETLOGWORDSIZE 4
  62. #else
  63. #define BSETWORDSIZE 32
  64. #define BSETLOGWORDSIZE 5
  65. #endif
  66. #endif
  68. #define BSETWORDSIZE 8
  69. #define BSETLOGWORDSIZE 3 /* SetWordType is 8bits */
  71. #define BSETMODWORD(x) ((x) & (BSETWORDSIZE-1)) /* x % BSETWORDSIZE */
  72. #define BSETDIVWORD(x) ((x) >> BSETLOGWORDSIZE) /* x / BSETWORDSIZE */
  74. /* This is not put into the global pccts_parser structure because it is
  75.  * hidden and does not need to be saved during a "save state" operation
  76.  */
  77. /* maximum of 32 bits/unsigned int and must be 8 bits/byte */
  78. static SetWordType bitmask[] = {
  79. 0x00000001, 0x00000002, 0x00000004, 0x00000008,
  80. 0x00000010, 0x00000020, 0x00000040, 0x00000080
  81. };
  83. #ifdef zzTRACE_RULES
  84. int  zzTraceOptionValueDefault=1;
  85. int  zzTraceOptionValue=1;
  86. int  zzTraceGuessOptionValue=1;
  87. char *zzTraceCurrentRuleName=NULL;
  88. int  zzTraceDepth=0;
  89. #endif
  91. int  zzGuessSeq=0;          /* MR10 */
  92. int  zzSyntaxErrCount=0;    /* MR11 */
  93. int  zzLexErrCount=0;       /* MR11 */
  95. void
  96. #ifdef __USE_PROTOS
  97. zzresynch(SetWordType *wd,SetWordType mask)
  98. #else
  99. zzresynch(wd,mask)
  100. SetWordType *wd, mask;
  101. #endif
  102. {
  103. static int consumed = 1;
  105. /* if you enter here without having consumed a token from last resynch
  106.  * force a token consumption.
  107.  */
  108. if ( !consumed ) {zzCONSUME; consumed=1; return;}   /* MR10 */
  110. /* if current token is in resynch set, we've got what we wanted */
  111. if ( wd[LA(1)]&mask || LA(1) == zzEOF_TOKEN ) {consumed=0; return;}
  113. /* scan until we find something in the resynch set */
  114. while ( !(wd[LA(1)]&mask) && LA(1) != zzEOF_TOKEN ) {zzCONSUME;}
  115. consumed=1;
  116. }
  118. /*                                                                          */
  119. /*  7-Apr-97 133MR1 for C++ and MR7 for C                                   */
  120. /*         Change suggested by Eli Sternheim (eli@interhdl.com)           */
  121. /*                                                                          */
  123. void
  124. #ifdef __USE_PROTOS
  125. zzconsumeUntil(SetWordType *st)
  126. #else
  127. zzconsumeUntil(st)
  128. SetWordType *st;
  129. #endif
  130. {
  131.     int     tmp;                                                     /* MR7 */
  132. while ( !zzset_el( (tmp=LA(1)), st) && tmp!=1 /* Eof */) {       /* MR7 */
  133.                                                       zzCONSUME; }   /* MR7 */
  134. }
  136. /*                                                                          */
  137. /*  7-Apr-97 133MR1 for C++ and MR7 for C                                   */
  138. /*         Change suggested by Eli Sternheim (eli@interhdl.com)           */
  139. /*                                                                          */
  141. void
  142. #ifdef __USE_PROTOS
  143. zzconsumeUntilToken(int t)
  144. #else
  145. zzconsumeUntilToken(t)
  146. int t;
  147. #endif
  148. {
  149.     int     tmp;                                                     /* MR7 */
  150. while ( (tmp=LA(1)) !=t && tmp!=1 /* Eof */) { zzCONSUME; }      /* MR7 */
  151. }
  153. /* input looks like:
  154.  * zzFAIL(k, e1, e2, ...,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText)
  155.  * where the zzMiss stuff is set here to the token that did not match
  156.  * (and which set wasn't it a member of).
  157.  */
  158. void
  159. #ifdef __USE_PROTOS
  160. zzFAIL(int k, ...)
  161. #else
  162. zzFAIL(va_alist)
  163. va_dcl
  164. #endif
  165. {
  166. #ifdef LL_K
  167. static char text[LL_K*ZZLEXBUFSIZE+1];
  168. SetWordType *f[LL_K];
  169. #else
  170. static char text[ZZLEXBUFSIZE+1];
  171. SetWordType *f[1];
  172. #endif
  173. SetWordType **miss_set;
  174. char **miss_text;
  175. int *bad_tok;
  176. char **bad_text;
  177. int *err_k;
  178. int i;
  179. va_list ap;
  180. #ifndef __USE_PROTOS
  181. int k;
  182. #endif
  183. #ifdef __USE_PROTOS
  184. va_start(ap, k);
  185. #else
  186. va_start(ap);
  187. k = va_arg(ap, int); /* how many lookahead sets? */
  188. #endif
  189. text[0] = '';
  190. for (i=1; i<=k; i++) /* collect all lookahead sets */
  191. {
  192. f[i-1] = va_arg(ap, SetWordType *);
  193. }
  194. for (i=1; i<=k; i++) /* look for offending token */
  195. {
  196. if ( i>1 ) strcat(text, " ");
  197. strcat(text, LATEXT(i));
  198. if ( !zzset_el((unsigned)LA(i), f[i-1]) ) break;
  199. }
  200. miss_set = va_arg(ap, SetWordType **);
  201. miss_text = va_arg(ap, char **);
  202. bad_tok = va_arg(ap, int *);
  203. bad_text = va_arg(ap, char **);
  204. err_k = va_arg(ap, int *);
  205. if ( i>k )
  206. {
  207. /* bad; lookahead is permutation that cannot be matched,
  208.  * but, the ith token of lookahead is valid at the ith position
  209.  * (The old LL sub 1 (k) versus LL(k) parsing technique)
  210.  */
  211. *miss_set = NULL;
  212. *miss_text = zzlextext;
  213. *bad_tok = LA(1);
  214. *bad_text = LATEXT(1);
  215. *err_k = k;
  216. return;
  217. }
  218. /* fprintf(stderr, "%s not in %dth setn", zztokens[LA(i)], i);*/
  219. *miss_set = f[i-1];
  220. *miss_text = text;
  221. *bad_tok = LA(i);
  222. *bad_text = LATEXT(i);
  223. if ( i==1 ) *err_k = 1;
  224. else *err_k = k;
  225. }
  227. #ifdef __USE_PROTOS
  228. void zzTraceGuessDone(zzantlr_state *state)
  229. #else
  230. void zzTraceGuessDone(state)
  231.   zzantlr_state     *state;
  232. #endif
  233. {
  234. #ifdef zzTRACE_RULES
  235. #ifdef ZZCAN_GUESS
  237.   int   doIt=0;
  239.   if (zzTraceCurrentRuleName == NULL) return;
  241.   if (zzTraceOptionValue <= 0) {
  242.     doIt=0;
  243.   } else if (zzTraceGuessOptionValue <= 0) {
  244.     doIt=0;
  245.   } else {
  246.     doIt=1;
  247.   };
  249.   if (doIt) {
  250.     fprintf(stderr,"guess done - returning to rule %s {"%s"} at depth %d",
  251.         state->traceCurrentRuleName,
  252.         LATEXT(1),
  253.         state->traceDepth);
  254.     if (state->guessing != 0) {
  255.       fprintf(stderr," (guess mode continues - an enclosing guess is still active)");
  256.     } else {
  257.       fprintf(stderr," (guess mode ends)");
  258.     };
  259.     fprintf(stderr,"n");
  260.   };
  261. #endif
  262. #endif
  263. }
  265. void
  266. #ifdef __USE_PROTOS
  267. zzsave_antlr_state(zzantlr_state *buf)
  268. #else
  269. zzsave_antlr_state(buf)
  270. zzantlr_state *buf;
  271. #endif
  272. {
  273. #ifdef LL_K
  274. int     i;
  275. #endif
  277. #ifdef ZZCAN_GUESS
  278. buf->guess_start = zzguess_start;
  279. buf->guessing = zzguessing;
  280. #endif
  281. buf->asp = zzasp;
  282. #ifdef GENAST
  283. buf->ast_sp = zzast_sp;
  284. #endif
  285. #ifdef ZZINF_LOOK
  286. buf->inf_labase = zzinf_labase;
  287. buf->inf_last = zzinf_last;
  289. /* MR6  Gunnar Rxnning (gunnar@candleweb.no)                                */
  290. /* MR6   Additional state needs to be saved/restored                       */
  292.    buf->inf_tokens = zzinf_tokens;                                  /* MR6 */
  293. buf->inf_text = zzinf_text;                                      /* MR6 */
  294. buf->inf_text_buffer = zzinf_text_buffer;                        /* MR6 */
  295. buf->inf_line = zzinf_line;                              /* MR6 */
  297. #endif
  298. #ifdef DEMAND_LOOK
  299. buf->dirty = zzdirty;
  300. #endif
  301. #ifdef LL_K
  302. for (i=0; i<LL_K; i++) buf->tokenLA[i] = zztokenLA[i];
  303. for (i=0; i<LL_K; i++) strcpy(buf->textLA[i], zztextLA[i]);
  304. buf->lap = zzlap;
  305. buf->labase = zzlabase;
  306. #else
  307. buf->token = zztoken;
  308. strcpy(buf->text, zzlextext);
  309. #endif
  310. #ifdef zzTRACE_RULES
  312.     /* MR10 */
  314.     buf->traceOptionValue=zzTraceOptionValue;
  315.     buf->traceGuessOptionValue=zzTraceGuessOptionValue;
  316.     buf->traceCurrentRuleName=zzTraceCurrentRuleName;
  317.     buf->traceDepth=zzTraceDepth;
  318. #endif
  319. }
  321. void
  322. #ifdef __USE_PROTOS
  323. zzrestore_antlr_state(zzantlr_state *buf)
  324. #else
  325. zzrestore_antlr_state(buf)
  326. zzantlr_state *buf;
  327. #endif
  328. {
  330. #ifdef zzTRACE_RULES
  331.     int     prevTraceOptionValue;
  332. #endif
  334. #ifdef LL_K
  335. int     i;
  336. #endif
  338. #ifdef ZZCAN_GUESS
  339. zzguess_start = buf->guess_start;
  340. zzguessing = buf->guessing;
  341. #endif
  342. zzasp = buf->asp;
  343. #ifdef GENAST
  344. zzast_sp = buf->ast_sp;
  345. #endif
  346. #ifdef ZZINF_LOOK
  347. zzinf_labase = buf->inf_labase;
  348. zzinf_last = buf->inf_last;
  350. /* MR6  Gunnar Rxnning (gunnar@candleweb.no)                                */
  351. /* MR6   Additional state needs to be saved/restored                       */
  353. zzinf_tokens = buf->inf_tokens;                                  /* MR6 */
  354. zzinf_text = buf->inf_text;                                      /* MR6 */
  355. zzinf_text_buffer = buf->inf_text_buffer;                        /* MR6 */
  356. zzinf_line = buf->inf_line;                              /* MR6 */
  357. #endif
  358. #ifdef DEMAND_LOOK
  359. zzdirty = buf->dirty;
  360. #endif
  361. #ifdef LL_K
  362. for (i=0; i<LL_K; i++) zztokenLA[i] = buf->tokenLA[i];
  363. for (i=0; i<LL_K; i++) strcpy(zztextLA[i], buf->textLA[i]);
  364. zzlap = buf->lap;
  365. zzlabase = buf->labase;
  366. #else
  367. zztoken = buf->token;
  368. strcpy(zzlextext, buf->text);
  369. #endif
  370. #ifdef zzTRACE_RULES
  372.     prevTraceOptionValue=zzTraceOptionValue;
  373.     zzTraceOptionValue=buf->traceOptionValue;
  374.     if ( (prevTraceOptionValue > 0) !=
  375.              (zzTraceOptionValue > 0)) {
  376.       if (zzTraceOptionValue > 0) {
  377.         fprintf(stderr,"trace enable restored in rule %s depth %dn",
  378.                         zzTraceCurrentRuleName,zzTraceDepth);
  379.       };
  380.       if (zzTraceOptionValue <= 0) {
  381.         fprintf(stderr,"trace disable restored in rule %s depth %dn",
  382.                         zzTraceCurrentRuleName,zzTraceDepth);
  383.       };
  384.     };
  386.     zzTraceOptionValue=buf->traceOptionValue;            /* MR10 */
  387.     zzTraceGuessOptionValue=buf->traceGuessOptionValue;  /* MR10 */
  388.     zzTraceCurrentRuleName=buf->traceCurrentRuleName;    /* MR10 */
  389.     zzTraceDepth=buf->traceDepth;                        /* MR10 */
  390.     zzTraceGuessDone(buf);                               /* MR10 */
  391. #endif
  392. }
  394. void
  395. #ifdef __USE_PROTOS
  396. zzedecode(SetWordType *a)
  397. #else
  398. zzedecode(a)
  399. SetWordType *a;
  400. #endif
  401. {
  402. register SetWordType *p = a;
  403. register SetWordType *endp = &(p[zzSET_SIZE]);
  404. register unsigned e = 0;
  406. if ( zzset_deg(a)>1 ) fprintf(stderr, " {");
  407. do {
  408. register SetWordType t = *p;
  409. register SetWordType *b = &(bitmask[0]);
  410. do {
  411. if ( t & *b ) fprintf(stderr, " %s", zztokens[e]);
  412. e++;
  413. } while (++b < &(bitmask[sizeof(SetWordType)*8]));
  414. } while (++p < endp);
  415. if ( zzset_deg(a)>1 ) fprintf(stderr, " }");
  416. }
  418. #ifndef USER_ZZSYN
  419. /* standard error reporting function */
  420. void
  421. #ifdef __USE_PROTOS
  422. zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text)
  423. #else
  424. zzsyn(text, tok, egroup, eset, etok, k, bad_text)
  425. char *text, *egroup, *bad_text;
  426. int tok;
  427. int etok;
  428. int k;
  429. SetWordType *eset;
  430. #endif
  431. {
  433.     zzSyntaxErrCount++;                             /* MR11 */
  434. fprintf(stderr, "line %d: syntax error at "%s"", zzline, (tok==zzEOF_TOKEN)?"EOF":bad_text);
  435. if ( !etok && !eset ) {fprintf(stderr, "n"); return;}
  436. if ( k==1 ) fprintf(stderr, " missing");
  437. else
  438. {
  439. fprintf(stderr, "; "%s" not", bad_text);
  440. if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
  441. }
  442. if ( zzset_deg(eset)>0 ) zzedecode(eset);
  443. else fprintf(stderr, " %s", zztokens[etok]);
  444. if ( strlen(egroup) > 0 ) fprintf(stderr, " in %s", egroup);
  445. fprintf(stderr, "n");
  446. }
  447. #endif
  449. /* is b an element of set p? */
  450. int
  451. #ifdef __USE_PROTOS
  452. zzset_el(unsigned b, SetWordType *p)
  453. #else
  454. zzset_el(b,p)
  455. unsigned b;
  456. SetWordType *p;
  457. #endif
  458. {
  459. return( p[BSETDIVWORD(b)] & bitmask[BSETMODWORD(b)] );
  460. }
  462. int
  463. #ifdef __USE_PROTOS
  464. zzset_deg(SetWordType *a)
  465. #else
  466. zzset_deg(a)
  467. SetWordType *a;
  468. #endif
  469. {
  470. /* Fast compute degree of a set... the number
  471.    of elements present in the set.  Assumes
  472.    that all word bits are used in the set
  473. */
  474. register SetWordType *p = a;
  475. register SetWordType *endp = &(a[zzSET_SIZE]);
  476. register int degree = 0;
  478. if ( a == NULL ) return 0;
  479. while ( p < endp )
  480. {
  481. register SetWordType t = *p;
  482. register SetWordType *b = &(bitmask[0]);
  483. do {
  484. if (t & *b) ++degree;
  485. } while (++b < &(bitmask[sizeof(SetWordType)*8]));
  486. p++;
  487. }
  489. return(degree);
  490. }
  492. #ifdef DEMAND_LOOK
  494. #ifdef LL_K
  495. int
  496. #ifdef __USE_PROTOS
  497. _zzmatch(int _t, char **zzBadText, char **zzMissText,
  498. int *zzMissTok, int *zzBadTok,
  499. SetWordType **zzMissSet)
  500. #else
  501. _zzmatch(_t, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
  502. int _t;
  503. char **zzBadText;
  504. char **zzMissText;
  505. int *zzMissTok, *zzBadTok;
  506. SetWordType **zzMissSet;
  507. #endif
  508. {
  509. if ( zzdirty==LL_K ) {
  510. zzCONSUME;
  511. }
  512. if ( LA(1)!=_t ) {
  513. *zzBadText = *zzMissText=LATEXT(1);
  514. *zzMissTok= _t; *zzBadTok=LA(1);
  515. *zzMissSet=NULL;
  516. return 0;
  517. }
  518. zzMakeAttr
  519. zzdirty++;
  520. zzlabase++;
  521. return 1;
  522. }
  524. int
  525. #ifdef __USE_PROTOS
  526. _zzmatch_wsig(int _t)
  527. #else
  528. _zzmatch_wsig(_t)
  529. int _t;
  530. #endif
  531. {
  532. if ( zzdirty==LL_K ) {
  533. zzCONSUME;
  534. }
  535. if ( LA(1)!=_t ) {
  536. return 0;
  537. }
  538. zzMakeAttr
  539. zzdirty++;
  540. zzlabase++;
  541. return 1;
  542. }
  544. #else
  546. int
  547. #ifdef __USE_PROTOS
  548. _zzmatch(int _t, char **zzBadText, char **zzMissText,
  549.  int *zzMissTok, int *zzBadTok, SetWordType **zzMissSet)
  550. #else
  551. _zzmatch(_t, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
  552. int _t;
  553. char **zzBadText;
  554. char **zzMissText;
  555. int *zzMissTok, *zzBadTok;
  556. SetWordType **zzMissSet;
  557. #endif
  558. {
  559. if ( zzdirty ) {zzCONSUME;}
  560. if ( LA(1)!=_t ) {
  561. *zzBadText = *zzMissText=LATEXT(1);
  562. *zzMissTok= _t; *zzBadTok=LA(1);
  563. *zzMissSet=NULL;
  564. return 0;
  565. }
  566. zzdirty = 1;
  567. zzMakeAttr
  568. return 1;
  569. }
  571. int
  572. #ifdef __USE_PROTOS
  573. _zzmatch_wsig(int _t)
  574. #else
  575. _zzmatch_wsig(_t)
  576. int _t;
  577. #endif
  578. {
  579. if ( zzdirty ) {zzCONSUME;}
  580. if ( LA(1)!=_t ) {
  581. return 0;
  582. }
  583. zzdirty = 1;
  584. zzMakeAttr
  585. return 1;
  586. }
  588. #endif /*LL_K*/
  590. #else
  592. int
  593. #ifdef __USE_PROTOS
  594. _zzmatch(int _t, char **zzBadText, char **zzMissText,
  595. int *zzMissTok, int *zzBadTok,
  596. SetWordType **zzMissSet)
  597. #else
  598. _zzmatch(_t, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
  599. int _t;
  600. char **zzBadText;
  601. char **zzMissText;
  602. int *zzMissTok, *zzBadTok;
  603. SetWordType **zzMissSet;
  604. #endif
  605. {
  606. if ( LA(1)!=_t ) {
  607. *zzBadText = *zzMissText=LATEXT(1);
  608. *zzMissTok= _t; *zzBadTok=LA(1);
  609. *zzMissSet=NULL;
  610. return 0;
  611. }
  612. zzMakeAttr
  613. return 1;
  614. }
  616. int
  617. #ifdef __USE_PROTOS
  618. _zzmatch_wsig(int _t)
  619. #else
  620. _zzmatch_wsig(_t)
  621. int _t;
  622. #endif
  623. {
  624. if ( LA(1)!=_t ) return 0;
  625. zzMakeAttr
  626. return 1;
  627. }
  629. #endif /*DEMAND_LOOK*/
  631. #ifdef ZZINF_LOOK
  632. void
  633. #ifdef __USE_PROTOS
  634. _inf_zzgettok(void)
  635. #else
  636. _inf_zzgettok()
  637. #endif
  638. {
  639. if ( zzinf_labase >= zzinf_last )
  640. {NLA = zzEOF_TOKEN; strcpy(NLATEXT, "");}
  641. else {
  642. NLA = zzinf_tokens[zzinf_labase];
  643. zzline = zzinf_line[zzinf_labase]; /* wrong in 1.21 */
  644. strcpy(NLATEXT, zzinf_text[zzinf_labase]);
  645. zzinf_labase++; 
  646. }
  647. }
  648. #endif
  650. #ifdef ZZINF_LOOK
  651. /* allocate default size text,token and line arrays;
  652.  * then, read all of the input reallocing the arrays as needed.
  653.  * Once the number of total tokens is known, the LATEXT(i) array (zzinf_text)
  654.  * is allocated and it's pointers are set to the tokens in zzinf_text_buffer.
  655.  */
  656. void
  657. #ifdef __USE_PROTOS
  658. zzfill_inf_look(void)
  659. #else
  660. zzfill_inf_look()
  661. #endif
  662. {
  663. int tok, line;
  664. int zzinf_token_buffer_size = ZZINF_DEF_TOKEN_BUFFER_SIZE;
  665. int zzinf_text_buffer_size = ZZINF_DEF_TEXT_BUFFER_SIZE;
  666. int zzinf_text_buffer_index = 0;
  667. int zzinf_lap = 0;
  669. /* allocate text/token buffers */
  670. zzinf_text_buffer = (char *) malloc(zzinf_text_buffer_size);
  671. if ( zzinf_text_buffer == NULL )
  672. {
  673. fprintf(stderr, "cannot allocate lookahead text buffer (%d bytes)n",
  674. zzinf_text_buffer_size);
  675. exit(PCCTS_EXIT_FAILURE);
  676. }
  677. zzinf_tokens = (int *) calloc(zzinf_token_buffer_size,sizeof(int));
  678. if ( zzinf_tokens == NULL )
  679. {
  680. fprintf(stderr, "cannot allocate token buffer (%d tokens)n",
  681. zzinf_token_buffer_size);
  682. exit(PCCTS_EXIT_FAILURE);
  683. }
  684.     zzinf_line = (int *) calloc(zzinf_token_buffer_size,sizeof(int));
  685.     if ( zzinf_line == NULL )
  686.     {
  687.         fprintf(stderr, "cannot allocate line buffer (%d ints)n",
  688.                 zzinf_token_buffer_size);
  689.         exit(PCCTS_EXIT_FAILURE);
  690. }
  692. /* get tokens, copying text to text buffer */
  693. zzinf_text_buffer_index = 0;
  694. do {
  695. zzgettok();
  696. line = zzreal_line;
  697. while ( zzinf_lap>=zzinf_token_buffer_size )
  698. {
  699. zzinf_token_buffer_size += ZZINF_BUFFER_TOKEN_CHUNK_SIZE;
  700. zzinf_tokens = (int *) realloc(zzinf_tokens,
  701.  zzinf_token_buffer_size*sizeof(int));
  702. if ( zzinf_tokens == NULL )
  703. {
  704. fprintf(stderr, "cannot allocate lookahead token buffer (%d tokens)n",
  705. zzinf_token_buffer_size);
  706. exit(PCCTS_EXIT_FAILURE);
  707. }
  708.             zzinf_line = (int *) realloc(zzinf_line,
  709.                                          zzinf_token_buffer_size*sizeof(int));
  710.             if ( zzinf_line == NULL )
  711.             {
  712.                 fprintf(stderr, "cannot allocate lookahead line buffer (%d ints)n",
  713.                         zzinf_token_buffer_size);
  714.                 exit(PCCTS_EXIT_FAILURE);
  715. }
  717. }
  718. while ( (zzinf_text_buffer_index+strlen(NLATEXT)+1) >= zzinf_text_buffer_size )
  719. {
  720. zzinf_text_buffer_size += ZZINF_BUFFER_TEXT_CHUNK_SIZE;
  721. zzinf_text_buffer = (char *) realloc(zzinf_text_buffer,
  722.  zzinf_text_buffer_size);
  723. if ( zzinf_text_buffer == NULL )
  724. {
  725. fprintf(stderr, "cannot allocate lookahead text buffer (%d bytes)n",
  726. zzinf_text_buffer_size);
  727. exit(PCCTS_EXIT_FAILURE);
  728. }
  729. }
  730. /* record token and text and line of input symbol */
  731. tok = zzinf_tokens[zzinf_lap] = NLA;
  732. strcpy(&zzinf_text_buffer[zzinf_text_buffer_index], NLATEXT);
  733. zzinf_text_buffer_index += strlen(NLATEXT)+1;
  734.         zzinf_line[zzinf_lap] = line;
  735. zzinf_lap++;
  736. } while (tok!=zzEOF_TOKEN);
  737. zzinf_labase = 0;
  738. zzinf_last = zzinf_lap-1;
  740. /* allocate ptrs to text of ith token */
  741. zzinf_text = (char **) calloc(zzinf_last+1,sizeof(char *));
  742. if ( zzinf_text == NULL )
  743. {
  744. fprintf(stderr, "cannot allocate lookahead text buffer (%d)n",
  745. zzinf_text_buffer_size);
  746. exit(PCCTS_EXIT_FAILURE);
  747. }
  748. zzinf_text_buffer_index = 0;
  749. zzinf_lap = 0;
  750. /* set ptrs so that zzinf_text[i] is the text of the ith token found on input */
  751. while (zzinf_lap<=zzinf_last)
  752. {
  753.     zzinf_text[zzinf_lap++] = &zzinf_text_buffer[zzinf_text_buffer_index];
  754. zzinf_text_buffer_index += strlen(&zzinf_text_buffer[zzinf_text_buffer_index])+1;
  755. }
  756. }
  757. #endif
  759. int
  760. #ifdef __USE_PROTOS
  761. _zzsetmatch(SetWordType *e, char **zzBadText, char **zzMissText,
  762. int *zzMissTok, int *zzBadTok,
  763. SetWordType **zzMissSet)
  764. #else
  765. _zzsetmatch(e, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
  766. SetWordType *e;
  767. char **zzBadText;
  768. char **zzMissText;
  769. int *zzMissTok, *zzBadTok;
  770. SetWordType **zzMissSet;
  771. #endif
  772. {
  773. #ifdef DEMAND_LOOK
  774. #ifdef LL_K
  775. if ( zzdirty==LL_K ) {zzCONSUME;}
  776. #else
  777. if ( zzdirty ) {zzCONSUME;}
  778. #endif
  779. #endif
  780. if ( !zzset_el((unsigned)LA(1), e) ) {
  781. *zzBadText = LATEXT(1); *zzMissText=NULL;
  782. *zzMissTok= 0; *zzBadTok=LA(1);
  783. *zzMissSet=e;
  784. return 0;
  785. }
  786. zzMakeAttr           /* MR14 Ger Hobbelt (hobbelt@axa.nl) */
  787. #ifdef DEMAND_LOOK
  788. #ifdef LL_K
  789. zzdirty++;
  790.     zzlabase++;          /* MR14 Ger Hobbelt (hobbelt@axa.nl) */
  791. #else
  792. zzdirty = 1;
  793. #endif
  794. #endif
  795. return 1;
  796. }
  798. int
  799. #ifdef __USE_PROTOS
  800. _zzmatch_wdfltsig(int tokenWanted, SetWordType *whatFollows)
  801. #else
  802. _zzmatch_wdfltsig(tokenWanted, whatFollows)
  803. int tokenWanted;
  804. SetWordType *whatFollows;
  805. #endif
  806. {
  807. #ifdef DEMAND_LOOK
  808. #ifdef LL_K
  809. if ( zzdirty==LL_K ) {
  810. zzCONSUME;
  811. }
  812. #else
  813. if ( zzdirty ) {zzCONSUME;}
  814. #endif
  815. #endif
  817. if ( LA(1)!=tokenWanted )
  818. {
  819.         zzSyntaxErrCount++;     /* MR11 */
  820. fprintf(stderr,
  821. "line %d: syntax error at "%s" missing %sn",
  822. zzline,
  823. (LA(1)==zzEOF_TOKEN)?"<eof>":LATEXT(1),
  824. zztokens[tokenWanted]);
  825. zzconsumeUntil( whatFollows );
  826. return 0;
  827. }
  828. else {
  829. zzMakeAttr
  830. #ifdef DEMAND_LOOK
  831. #ifdef LL_K
  832. zzdirty++;
  833. zzlabase++;
  834. #else
  835. zzdirty = 1;
  836. #endif
  837. #else
  838. /* zzCONSUME;  consume if not demand lookahead */
  839. #endif
  840. return 1;
  841. }
  842. }
  844. int
  845. #ifdef __USE_PROTOS
  846. _zzsetmatch_wdfltsig(SetWordType *tokensWanted,
  847.  int tokenTypeOfSet,
  848.  SetWordType *whatFollows)
  849. #else
  850. _zzsetmatch_wdfltsig(tokensWanted, tokenTypeOfSet, whatFollows)
  851. SetWordType *tokensWanted;
  852. int tokenTypeOfSet;
  853. SetWordType *whatFollows;
  854. #endif
  855. {
  856. #ifdef DEMAND_LOOK
  857. #ifdef LL_K
  858. if ( zzdirty==LL_K ) {zzCONSUME;}
  859. #else
  860. if ( zzdirty ) {zzCONSUME;}
  861. #endif
  862. #endif
  863. if ( !zzset_el((unsigned)LA(1), tokensWanted) )
  864. {
  865.         zzSyntaxErrCount++;     /* MR11 */
  866. fprintf(stderr,
  867. "line %d: syntax error at "%s" missing %sn",
  868. zzline,
  869. (LA(1)==zzEOF_TOKEN)?"<eof>":LATEXT(1),
  870. zztokens[tokenTypeOfSet]);
  871. zzconsumeUntil( whatFollows );
  872. return 0;
  873. }
  874. else {
  875. zzMakeAttr
  876. #ifdef DEMAND_LOOK
  877. #ifdef LL_K
  878. zzdirty++;
  879. zzlabase++;
  880. #else
  881. zzdirty = 1;
  882. #endif
  883. #else
  884. /* zzCONSUME; consume if not demand lookahead */
  885. #endif
  886. return 1;
  887. }
  888. }
  890. int
  891. #ifdef __USE_PROTOS
  892. _zzsetmatch_wsig(SetWordType *e)
  893. #else
  894. _zzsetmatch_wsig(e)
  895. SetWordType *e;
  896. #endif
  897. {
  898. #ifdef DEMAND_LOOK
  899. #ifdef LL_K
  900. if ( zzdirty==LL_K ) {zzCONSUME;}
  901. #else
  902. if ( zzdirty ) {zzCONSUME;}
  903. #endif
  904. #endif
  905. if ( !zzset_el((unsigned)LA(1), e) ) return 0;
  906. zzMakeAttr           /* MR14 Ger Hobbelt (hobbelt@axa.nl) */
  907. #ifdef DEMAND_LOOK
  908. #ifdef LL_K
  909. zzdirty++;
  910.     zzlabase++;          /* MR14 Ger Hobbelt (hobbelt@axa.nl) */
  911. #else
  912. zzdirty = 1;
  913. #endif
  914. #endif
  915. return 1;
  916. }
  918. #ifdef USER_ZZMODE_STACK
  919. static int  zzmstk[ZZMAXSTK] = { -1 };
  920. static int  zzmdep = 0;
  921. static char zzmbuf[70];
  923. void
  924. #ifdef __USE_PROTOS
  925. zzmpush( int m )
  926. #else
  927. zzmpush( m )
  928. int m;
  929. #endif
  930. {
  931.    if(zzmdep == ZZMAXSTK - 1) {
  932.      sprintf(zzmbuf, "Mode stack overflow ");
  933.      zzerr(zzmbuf);
  934.    } else {
  935.      zzmstk[zzmdep++] = zzauto;
  936.      zzmode(m);
  937.    }
  938. }
  940. void
  941. #ifdef __USE_PROTOS
  942. zzmpop( void )
  943. #else
  944. zzmpop( )
  945. #endif
  946. {
  947.    if(zzmdep == 0)
  948.    {  sprintf(zzmbuf, "Mode stack underflow ");
  949.       zzerr(zzmbuf);
  950.    }
  951.    else
  952.    {  zzmdep--;
  953.       zzmode(zzmstk[zzmdep]);
  954.    }
  955. }
  957. void
  958. #ifdef __USE_PROTOS
  959. zzsave_mode_stack( int modeStack[], int *modeLevel )
  960. #else
  961. zzsave_mode_stack( modeStack, modeLevel )
  962. int modeStack[];
  963. int *modeLevel;
  964. #endif
  965. {
  966.   int i;
  967.   memcpy(modeStack, zzmstk, sizeof(zzmstk));
  968.   *modeLevel = zzmdep;
  969.   zzmdep = 0;
  971.   return;
  972. }
  974. void
  975. #ifdef __USE_PROTOS
  976. zzrestore_mode_stack( int modeStack[], int *modeLevel )
  977. #else
  978. zzrestore_mode_stack( modeStack, modeLevel )
  979. int modeStack[];
  980. int *modeLevel;
  981. #endif
  982. {
  983.   int i;
  985.   memcpy(zzmstk, modeStack, sizeof(zzmstk));
  986.   zzmdep = *modeLevel;
  988.   return;
  989. }
  990. #endif /* USER_ZZMODE_STACK */
  992. void zzTraceReset() {
  993. #ifdef zzTRACE_RULES
  994.   zzTraceOptionValue=zzTraceOptionValueDefault;
  995.   zzTraceGuessOptionValue=1;
  996.   zzTraceCurrentRuleName=NULL;
  997.   zzTraceDepth=0;
  998. #endif
  999. }
  1001. void zzTraceGuessFail() {
  1003. #ifdef zzTRACE_RULES
  1004. #ifdef ZZCAN_GUESS
  1006.   int   doIt=0;
  1008.   if (zzTraceOptionValue <= 0) {
  1009.     doIt=0;
  1010.   } else if (zzguessing && zzTraceGuessOptionValue <= 0) {
  1011.     doIt=0;
  1012.   } else {
  1013.     doIt=1;
  1014.   };
  1016.   if (doIt) {
  1017.     fprintf(stderr,"guess failedn");
  1018.   };
  1019. #endif
  1020. #endif
  1021. }
  1023. /* zzTraceOption:
  1024.      zero value turns off trace
  1025. */
  1027. #ifdef __USE_PROTOS
  1028. void zzTraceIn(char * rule)
  1029. #else
  1030. void zzTraceIn(rule)
  1031.   char  *rule;
  1032. #endif
  1033. {
  1034. #ifdef zzTRACE_RULES
  1036.   int           doIt=0;
  1038.   zzTraceDepth++;
  1039.   zzTraceCurrentRuleName=rule;
  1041.   if (zzTraceOptionValue <= 0) {
  1042.     doIt=0;
  1043. #ifdef ZZCAN_GUESS
  1044.   } else if (zzguessing && zzTraceGuessOptionValue <= 0) {
  1045.     doIt=0;
  1046. #endif
  1047.   } else {
  1048.     doIt=1;
  1049.   };
  1051.   if (doIt) {
  1052.     fprintf(stderr,"enter rule %s {"%s"} depth %d",
  1053.             rule,
  1054.             LA(1)==1 ? "@" : LATEXT(1),
  1055.             zzTraceDepth);
  1056. #ifdef ZZCAN_GUESS
  1057.     if (zzguessing) fprintf(stderr," guessing");
  1058. #endif
  1059.     fprintf(stderr,"n");
  1060.   };
  1061. #endif
  1062.   return;
  1063. }
  1065. #ifdef __USE_PROTOS
  1066. void zzTraceOut(char * rule)
  1067. #else
  1068. void zzTraceOut(rule)
  1069.   char  *rule;
  1070. #endif
  1071. {
  1072. #ifdef zzTRACE_RULES
  1073.   int       doIt=0;
  1075.   zzTraceDepth--;
  1077.   if (zzTraceOptionValue <= 0) {
  1078.     doIt=0;
  1079. #ifdef ZZCAN_GUESS
  1080.   } else if (zzguessing && zzTraceGuessOptionValue <= 0) {
  1081.     doIt=0;
  1082. #endif
  1083.   } else {
  1084.     doIt=1;
  1085.   };
  1087.   if (doIt) {
  1088.     fprintf(stderr,"exit rule %s {"%s"} depth %d",
  1089.             rule,
  1090.             LA(1)==1 ? "@" : LATEXT(1),
  1091.             zzTraceDepth+1);
  1092. #ifdef ZZCAN_GUESS
  1093.     if (zzguessing) fprintf(stderr," guessing");
  1094. #endif
  1095.     fprintf(stderr,"n");
  1096.   };
  1097. #endif
  1098. }
  1100. #ifdef __USE_PROTOS
  1101. int zzTraceOption(int delta)
  1102. #else
  1103. int zzTraceOption(delta)
  1104.   int   delta;
  1105. #endif
  1106. {
  1107. #ifdef zzTRACE_RULES
  1108.     int     prevValue=zzTraceOptionValue;
  1110.     zzTraceOptionValue=zzTraceOptionValue+delta;
  1112.     if (zzTraceCurrentRuleName != NULL) {
  1113.       if (prevValue <= 0 && zzTraceOptionValue > 0) {
  1114.         fprintf(stderr,"trace enabled in rule %s depth %dn",
  1115.                                             zzTraceCurrentRuleName,zzTraceDepth);
  1116.       };
  1117.       if (prevValue > 0 && zzTraceOptionValue <= 0) {
  1118.         fprintf(stderr,"trace disabled in rule %s depth %dn",
  1119.                                             zzTraceCurrentRuleName,zzTraceDepth);
  1120.       };
  1121.     };
  1122.     return  prevValue;
  1123. #else
  1124.     return 0;
  1125. #endif
  1126. }
  1128. #ifdef __USE_PROTOS
  1129. int zzTraceGuessOption(int delta)
  1130. #else
  1131. int zzTraceGuessOption(delta)
  1132.   int   delta;
  1133. #endif
  1134. {
  1135. #ifdef zzTRACE_RULES
  1136. #ifdef ZZCAN_GUESS
  1137.     int     prevValue=zzTraceGuessOptionValue;
  1139.     zzTraceGuessOptionValue=zzTraceGuessOptionValue+delta;
  1141.     if (zzTraceCurrentRuleName != NULL) {
  1142.       if (prevValue <= 0 && zzTraceGuessOptionValue > 0) {
  1143.         fprintf(stderr,"guess trace enabled in rule %s depth %dn",
  1144.                                                 zzTraceCurrentRuleName,zzTraceDepth);
  1145.       };
  1146.       if (prevValue > 0 && zzTraceGuessOptionValue <= 0) {
  1147.         fprintf(stderr,"guess trace disabled in rule %s depth %dn",
  1148.                                                 zzTraceCurrentRuleName,zzTraceDepth);
  1149.       };
  1150.     };
  1151.     return prevValue;
  1152. #else
  1153.     return 0;
  1154. #endif
  1155. #else
  1156.     return 0;
  1157. #endif
  1158. }
  1160. #endif /* ERR_H */