~ubuntu-branches/ubuntu/utopic/cccc/utopic

« back to all changes in this revision

Viewing changes to pccts/h/err.h

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson
  • Date: 2003-08-23 04:34:05 UTC
  • Revision ID: james.westby@ubuntu.com-20030823043405-xnzd3mn3hwtvi6dr
Tags: upstream-3.pre81
ImportĀ upstreamĀ versionĀ 3.pre81

Show diffs side-by-side

added added

removed removed

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