Logo Search packages:      
Sourcecode: pccts version File versions  Download package

err.h

/*
 * err.h
 *
 * Standard error handling mechanism
 *
 * SOFTWARE RIGHTS
 *
 * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
 * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
 * company may do whatever they wish with source code distributed with
 * PCCTS or the code generated by PCCTS, including the incorporation of
 * PCCTS, or its output, into commerical software.
 *
 * We encourage users to develop software with PCCTS.  However, we do ask
 * that credit is given to us for developing PCCTS.  By "credit",
 * we mean that if you incorporate our source code into one of your
 * programs (commercial product, research project, or otherwise) that you
 * acknowledge this fact somewhere in the documentation, research report,
 * etc...  If you like PCCTS and have developed a nice tool with the
 * output, please mention that you developed it using PCCTS.  In
 * addition, we ask that this header remain intact in our source code.
 * As long as these guidelines are kept, we expect to continue enhancing
 * this system and expect to make other tools available as they are
 * completed.
 *
 * Has grown to hold all kinds of stuff (err.h is increasingly misnamed)
 *
 * ANTLR 1.33
 * Terence Parr
 * Parr Research Corporation
 * with Purdue University and AHPCRC, University of Minnesota
 * 1989-2000
 */

#ifndef ERR_H
#define ERR_H

#include "pcctscfg.h"
#include <stdlib.h>
#include <assert.h>

/*                                                          */
/*  7-Apr-97  133MR1                                              */
/*          Proper choice of STDC and cplusplus pre-processor symbols (?) */
/*                                                          */
#include "pccts_string.h"

#ifdef PCCTS_USE_STDARG
#include "pccts_stdarg.h"
#else
#include <varargs.h>
#endif

#ifdef DUM
/* Define usable bits per unsigned int word (used for set stuff) */
#ifdef PC
#define BSETWORDSIZE 16
#define BSETLOGWORDSIZE 4
#else
#define     BSETWORDSIZE 32
#define BSETLOGWORDSIZE 5
#endif
#endif

#define     BSETWORDSIZE 8
#define BSETLOGWORDSIZE 3           /* SetWordType is 8bits */

#define     BSETMODWORD(x) ((x) & (BSETWORDSIZE-1))         /* x % BSETWORDSIZE */
#define     BSETDIVWORD(x) ((x) >> BSETLOGWORDSIZE)         /* x / BSETWORDSIZE */

/* This is not put into the global pccts_parser structure because it is
 * hidden and does not need to be saved during a "save state" operation
 */
/* maximum of 32 bits/unsigned int and must be 8 bits/byte */
static SetWordType bitmask[] = {
      0x00000001, 0x00000002, 0x00000004, 0x00000008,
      0x00000010, 0x00000020, 0x00000040, 0x00000080
};

#ifdef zzTRACE_RULES
int  zzTraceOptionValueDefault=1;
int  zzTraceOptionValue=1;
int  zzTraceGuessOptionValue=1;
char *zzTraceCurrentRuleName=NULL;
int  zzTraceDepth=0;
#endif

int  zzGuessSeq=0;          /* MR10 */
int  zzSyntaxErrCount=0;    /* MR11 */
int  zzLexErrCount=0;       /* MR11 */

void
#ifdef __USE_PROTOS
zzresynch(SetWordType *wd,SetWordType mask)
#else
zzresynch(wd,mask)
SetWordType *wd, mask;
#endif
{
      static int consumed = 1;

      /* if you enter here without having consumed a token from last resynch
       * force a token consumption.
       */
      if ( !consumed ) {zzCONSUME; consumed=1; return;}   /* MR10 */

      /* if current token is in resynch set, we've got what we wanted */
      if ( wd[LA(1)]&mask || LA(1) == zzEOF_TOKEN ) {consumed=0; return;}
      
      /* scan until we find something in the resynch set */
      while ( !(wd[LA(1)]&mask) && LA(1) != zzEOF_TOKEN ) {zzCONSUME;}
      consumed=1;
}

/*                                                                          */
/*  7-Apr-97 133MR1 for C++ and MR7 for C                                   */
/*         Change suggested by Eli Sternheim (eli@interhdl.com)           */
/*                                                                          */

void
#ifdef __USE_PROTOS
zzconsumeUntil(SetWordType *st)
#else
zzconsumeUntil(st)
SetWordType *st;
#endif
{
    int     tmp;                                                     /* MR7 */
      while ( !zzset_el( (tmp=LA(1)), st) && tmp!=1 /* Eof */) {       /* MR7 */
                                                      zzCONSUME; }   /* MR7 */
}

/*                                                                          */
/*  7-Apr-97 133MR1 for C++ and MR7 for C                                   */
/*         Change suggested by Eli Sternheim (eli@interhdl.com)           */
/*                                                                          */

void
#ifdef __USE_PROTOS
zzconsumeUntilToken(int t)
#else
zzconsumeUntilToken(t)
int t;
#endif
{
    int     tmp;                                                     /* MR7 */
      while ( (tmp=LA(1)) !=t && tmp!=1 /* Eof */) { zzCONSUME; }      /* MR7 */
}

/* input looks like:
 *          zzFAIL(k, e1, e2, ...,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText)
 * where the zzMiss stuff is set here to the token that did not match
 * (and which set wasn't it a member of).
 */

#ifdef PCCTS_USE_STDARG
void zzFAIL(int k, ...)
#else
void zzFAIL(va_alist)
va_dcl
#endif
{
#ifdef LL_K
      static char text[LL_K*ZZLEXBUFSIZE+1];
      SetWordType *f[LL_K];
#else
      static char text[ZZLEXBUFSIZE+1];
      SetWordType *f[1];
#endif
      SetWordType **miss_set;
      char **miss_text;
      int *bad_tok;
      char **bad_text;
      int *err_k;
      int i;
      va_list ap;
#ifndef PCCTS_USE_STDARG                  /* MR20 */
      int k;
#endif
#ifdef PCCTS_USE_STDARG         /* MR20 */
      va_start(ap, k);
#else
      va_start(ap);
      k = va_arg(ap, int);    /* how many lookahead sets? */
#endif
    assert(k <= sizeof(f)/sizeof(f[0]));    /* MR20 G. Hobbelt */
      text[0] = '\0';
      for (i=1; i<=k; i++)    /* collect all lookahead sets */
      {
            f[i-1] = va_arg(ap, SetWordType *);
      }
      for (i=1; i<=k; i++)    /* look for offending token */
      {
            if ( i>1 ) strcat(text, " ");
            strcat(text, LATEXT(i));
            if ( !zzset_el((unsigned)LA(i), f[i-1]) ) break;
      }
      miss_set = va_arg(ap, SetWordType **);
      miss_text = va_arg(ap, char **);
      bad_tok = va_arg(ap, int *);
      bad_text = va_arg(ap, char **);
      err_k = va_arg(ap, int *);
      if ( i>k )
      {
            /* bad; lookahead is permutation that cannot be matched,
             * but, the ith token of lookahead is valid at the ith position
             * (The old LL sub 1 (k) versus LL(k) parsing technique)
             */
            *miss_set = NULL;
            *miss_text = zzlextext;
            *bad_tok = LA(1);
            *bad_text = LATEXT(1);
            *err_k = k;
            return;
      }
/*    fprintf(stderr, "%s not in %dth set\n", zztokens[LA(i)], i);*/
      *miss_set = f[i-1];
      *miss_text = text;
      *bad_tok = LA(i);
      *bad_text = LATEXT(i);
      if ( i==1 ) *err_k = 1;
      else *err_k = k;
}

#ifdef __USE_PROTOS
void zzTraceGuessDone(zzantlr_state *state)
#else
void zzTraceGuessDone(state)
  zzantlr_state     *state;
#endif
{
#ifdef zzTRACE_RULES
#ifdef ZZCAN_GUESS

  int   doIt=0;

  if (zzTraceCurrentRuleName == NULL) return;

  if (zzTraceOptionValue <= 0) {
    doIt=0;
  } else if (zzTraceGuessOptionValue <= 0) {
    doIt=0;
  } else {
    doIt=1;
  };

  if (doIt) {
    fprintf(stderr,"guess done - returning to rule %s {\"%s\"} at depth %d",
        state->traceCurrentRuleName,
        LATEXT(1),
        state->traceDepth);
    if (state->guessing != 0) {
      fprintf(stderr," (guess mode continues - an enclosing guess is still active)");
    } else {
      fprintf(stderr," (guess mode ends)");
    };
    fprintf(stderr,"\n");
  };
#endif
#endif
}

void
#ifdef __USE_PROTOS
zzsave_antlr_state(zzantlr_state *buf)
#else
zzsave_antlr_state(buf)
zzantlr_state *buf;
#endif
{
#ifdef LL_K
      int     i;
#endif

#ifdef ZZCAN_GUESS
      buf->guess_start = zzguess_start;
      buf->guessing = zzguessing;
#endif
      buf->asp = zzasp;
#ifdef GENAST
      buf->ast_sp = zzast_sp;
#endif
#ifdef ZZINF_LOOK
      buf->inf_labase = zzinf_labase;
      buf->inf_last = zzinf_last;

/* MR6      Gunnar Rxnning (gunnar@candleweb.no)                                */
/* MR6        Additional state needs to be saved/restored                       */

      buf->inf_tokens = zzinf_tokens;                                  /* MR6 */
      buf->inf_text = zzinf_text;                                      /* MR6 */
      buf->inf_text_buffer = zzinf_text_buffer;                        /* MR6 */
      buf->inf_line = zzinf_line;                                            /* MR6 */

#endif
#ifdef DEMAND_LOOK
      buf->dirty = zzdirty;
#endif
#ifdef LL_K
      for (i=0; i<LL_K; i++) buf->tokenLA[i] = zztokenLA[i];
      for (i=0; i<LL_K; i++) strcpy(buf->textLA[i], zztextLA[i]);
      buf->lap = zzlap;
      buf->labase = zzlabase;
#else
      buf->token = zztoken;
      strcpy(buf->text, zzlextext);
#endif
#ifdef zzTRACE_RULES

    /* MR10 */

    buf->traceOptionValue=zzTraceOptionValue;
    buf->traceGuessOptionValue=zzTraceGuessOptionValue;
    buf->traceCurrentRuleName=zzTraceCurrentRuleName;
    buf->traceDepth=zzTraceDepth;
#endif
}

void
#ifdef __USE_PROTOS
zzrestore_antlr_state(zzantlr_state *buf)
#else
zzrestore_antlr_state(buf)
zzantlr_state *buf;
#endif
{

#ifdef zzTRACE_RULES
    int     prevTraceOptionValue;
#endif

#ifdef LL_K
      int     i;
#endif

#ifdef ZZCAN_GUESS
      zzguess_start = buf->guess_start;
      zzguessing = buf->guessing;
#endif
      zzasp = buf->asp;
#ifdef GENAST
      zzast_sp = buf->ast_sp;
#endif
#ifdef ZZINF_LOOK
      zzinf_labase = buf->inf_labase;
      zzinf_last = buf->inf_last;

/* MR6      Gunnar Rxnning (gunnar@candleweb.no)                                */
/* MR6        Additional state needs to be saved/restored                       */

      zzinf_tokens = buf->inf_tokens;                                  /* MR6 */
      zzinf_text = buf->inf_text;                                      /* MR6 */
      zzinf_text_buffer = buf->inf_text_buffer;                        /* MR6 */
      zzinf_line = buf->inf_line;                                            /* MR6 */
#endif
#ifdef DEMAND_LOOK
      zzdirty = buf->dirty;
#endif
#ifdef LL_K
      for (i=0; i<LL_K; i++) zztokenLA[i] = buf->tokenLA[i];
      for (i=0; i<LL_K; i++) strcpy(zztextLA[i], buf->textLA[i]);
      zzlap = buf->lap;
      zzlabase = buf->labase;
#else
      zztoken = buf->token;
      strcpy(zzlextext, buf->text);
#endif
#ifdef zzTRACE_RULES

    prevTraceOptionValue=zzTraceOptionValue;
    zzTraceOptionValue=buf->traceOptionValue;
    if ( (prevTraceOptionValue > 0) !=
             (zzTraceOptionValue > 0)) {
      if (zzTraceOptionValue > 0) {
        fprintf(stderr,"trace enable restored in rule %s depth %d\n",
                        zzTraceCurrentRuleName,zzTraceDepth);
      };
      if (zzTraceOptionValue <= 0) {
        fprintf(stderr,"trace disable restored in rule %s depth %d\n",
                        zzTraceCurrentRuleName,zzTraceDepth);
      };
    };

    zzTraceOptionValue=buf->traceOptionValue;            /* MR10 */
    zzTraceGuessOptionValue=buf->traceGuessOptionValue;  /* MR10 */
    zzTraceCurrentRuleName=buf->traceCurrentRuleName;    /* MR10 */
    zzTraceDepth=buf->traceDepth;                        /* MR10 */
    zzTraceGuessDone(buf);                               /* MR10 */
#endif
}

void
#ifdef __USE_PROTOS
zzedecode(SetWordType *a)
#else
zzedecode(a)
SetWordType *a;
#endif
{
      register SetWordType *p = a;
      register SetWordType *endp = &(p[zzSET_SIZE]);
      register unsigned e = 0;

      if ( zzset_deg(a)>1 ) fprintf(stderr, " {");
      do {
            register SetWordType t = *p;
            register SetWordType *b = &(bitmask[0]);
            do {
                  if ( t & *b ) fprintf(stderr, " %s", zztokens[e]);
                  e++;
            } while (++b < &(bitmask[sizeof(SetWordType)*8]));
      } while (++p < endp);
      if ( zzset_deg(a)>1 ) fprintf(stderr, " }");
}

#ifndef USER_ZZSYN
/* standard error reporting function */
void
#ifdef __USE_PROTOS
zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text)
#else
zzsyn(text, tok, egroup, eset, etok, k, bad_text)
char *text, *egroup, *bad_text;
int tok;
int etok;
int k;
SetWordType *eset;
#endif
{
      
    zzSyntaxErrCount++;                             /* MR11 */
      fprintf(stderr, "line %d: syntax error at \"%s\"", zzline, (tok==zzEOF_TOKEN)?"EOF":bad_text);
      if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
      if ( k==1 ) fprintf(stderr, " missing");
      else
      {
            fprintf(stderr, "; \"%s\" not", bad_text);
            if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
      }
      if ( zzset_deg(eset)>0 ) zzedecode(eset);
      else fprintf(stderr, " %s", zztokens[etok]);
      if ( strlen(egroup) > 0 ) fprintf(stderr, " in %s", egroup);
      fprintf(stderr, "\n");
}
#endif

/* is b an element of set p? */
int
#ifdef __USE_PROTOS
zzset_el(unsigned b, SetWordType *p)
#else
zzset_el(b,p)
unsigned b;
SetWordType *p;
#endif
{
      return( p[BSETDIVWORD(b)] & bitmask[BSETMODWORD(b)] );
}

int
#ifdef __USE_PROTOS
zzset_deg(SetWordType *a)
#else
zzset_deg(a)
SetWordType *a;
#endif
{
      /* Fast compute degree of a set... the number
         of elements present in the set.  Assumes
         that all word bits are used in the set
      */
      register SetWordType *p = a;
      register SetWordType *endp = &(a[zzSET_SIZE]);
      register int degree = 0;

      if ( a == NULL ) return 0;
      while ( p < endp )
      {
            register SetWordType t = *p;
            register SetWordType *b = &(bitmask[0]);
            do {
                  if (t & *b) ++degree;
            } while (++b < &(bitmask[sizeof(SetWordType)*8]));
            p++;
      }

      return(degree);
}

#ifdef DEMAND_LOOK

#ifdef LL_K
int
#ifdef __USE_PROTOS
_zzmatch(int _t, char **zzBadText, char **zzMissText,
            int *zzMissTok, int *zzBadTok,
            SetWordType **zzMissSet)
#else
_zzmatch(_t, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
int _t;
char **zzBadText;
char **zzMissText;
int *zzMissTok, *zzBadTok;
SetWordType **zzMissSet;
#endif
{
      if ( zzdirty==LL_K ) {
            zzCONSUME;
      }
      if ( LA(1)!=_t ) {
            *zzBadText = *zzMissText=LATEXT(1); 
            *zzMissTok= _t; *zzBadTok=LA(1);
            *zzMissSet=NULL;                    
            return 0;
      }
      zzMakeAttr                                
      zzdirty++;                                
      zzlabase++;                               
      return 1;
}

int
#ifdef __USE_PROTOS
_zzmatch_wsig(int _t)
#else
_zzmatch_wsig(_t)
int _t;
#endif
{
      if ( zzdirty==LL_K ) {
            zzCONSUME;
      }
      if ( LA(1)!=_t ) {
            return 0;
      }
      zzMakeAttr                                
      zzdirty++;                                
      zzlabase++;                               
      return 1;
}

#else

int
#ifdef __USE_PROTOS
_zzmatch(int _t, char **zzBadText, char **zzMissText,
             int *zzMissTok, int *zzBadTok, SetWordType **zzMissSet)
#else
_zzmatch(_t, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
int _t;
char **zzBadText;
char **zzMissText;
int *zzMissTok, *zzBadTok;
SetWordType **zzMissSet;
#endif
{                                               
      if ( zzdirty ) {zzCONSUME;}         
      if ( LA(1)!=_t ) {
            *zzBadText = *zzMissText=LATEXT(1); 
            *zzMissTok= _t; *zzBadTok=LA(1);
            *zzMissSet=NULL;                    
            return 0;
      }                                               
      zzdirty = 1;                              
      zzMakeAttr                                
      return 1;
}

int
#ifdef __USE_PROTOS
_zzmatch_wsig(int _t)
#else
_zzmatch_wsig(_t)
int _t;
#endif
{
      if ( zzdirty ) {zzCONSUME;}         
      if ( LA(1)!=_t ) {
            return 0;
      }
      zzdirty = 1;                              
      zzMakeAttr                                
      return 1;
}

#endif /*LL_K*/

#else

int
#ifdef __USE_PROTOS
_zzmatch(int _t, char **zzBadText, char **zzMissText,
            int *zzMissTok, int *zzBadTok,
            SetWordType **zzMissSet)
#else
_zzmatch(_t, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet)
int _t;
char **zzBadText;
char **zzMissText;
int *zzMissTok, *zzBadTok;
SetWordType **zzMissSet;
#endif
{
      if ( LA(1)!=_t ) {                        
            *zzBadText = *zzMissText=LATEXT(1); 
            *zzMissTok= _t; *zzBadTok=LA(1);
            *zzMissSet=NULL;                    
            return 0;
      }
      zzMakeAttr
      return 1;
}

int
#ifdef __USE_PROTOS
_zzmatch_wsig(int _t)
#else
_zzmatch_wsig(_t)
int _t;
#endif
{
      if ( LA(1)!=_t ) return 0;
      zzMakeAttr                                
      return 1;
}

#endif /*DEMAND_LOOK*/

#ifdef ZZINF_LOOK
void
#ifdef __USE_PROTOS
_inf_zzgettok(void)
#else
_inf_zzgettok()
#endif
{
      if ( zzinf_labase >= zzinf_last )                           
            {NLA = zzEOF_TOKEN; strcpy(NLATEXT, "");} 
      else {                                                                  
            NLA = zzinf_tokens[zzinf_labase];
            zzline = zzinf_line[zzinf_labase];  /* wrong in 1.21 */
            strcpy(NLATEXT, zzinf_text[zzinf_labase]);            
            zzinf_labase++;                                             
      }                                                                       
}
#endif

#ifdef ZZINF_LOOK
/* allocate default size text,token and line arrays;
 * then, read all of the input reallocing the arrays as needed.
 * Once the number of total tokens is known, the LATEXT(i) array (zzinf_text)
 * is allocated and it's pointers are set to the tokens in zzinf_text_buffer.
 */
void
#ifdef __USE_PROTOS
zzfill_inf_look(void)
#else
zzfill_inf_look()
#endif
{
      int tok, line;
      int zzinf_token_buffer_size = ZZINF_DEF_TOKEN_BUFFER_SIZE;
      int zzinf_text_buffer_size = ZZINF_DEF_TEXT_BUFFER_SIZE;
      int zzinf_text_buffer_index = 0;
      int zzinf_lap = 0;

      /* allocate text/token buffers */
      zzinf_text_buffer = (char *) malloc(zzinf_text_buffer_size);
      if ( zzinf_text_buffer == NULL )
      {
            fprintf(stderr, "cannot allocate lookahead text buffer (%d bytes)\n",
            zzinf_text_buffer_size);
            exit(PCCTS_EXIT_FAILURE);                                                     
      }
      zzinf_tokens = (int *) calloc(zzinf_token_buffer_size,sizeof(int));
      if ( zzinf_tokens == NULL )
      {
            fprintf(stderr,   "cannot allocate token buffer (%d tokens)\n",
                        zzinf_token_buffer_size);
            exit(PCCTS_EXIT_FAILURE);                                                     
      }
    zzinf_line = (int *) calloc(zzinf_token_buffer_size,sizeof(int));
    if ( zzinf_line == NULL )
    {
        fprintf(stderr, "cannot allocate line buffer (%d ints)\n",
                zzinf_token_buffer_size);
        exit(PCCTS_EXIT_FAILURE);
      }

      /* get tokens, copying text to text buffer */
      zzinf_text_buffer_index = 0;
      do {
            zzgettok();
            line = zzreal_line;
            while ( zzinf_lap>=zzinf_token_buffer_size )
            {
                  zzinf_token_buffer_size += ZZINF_BUFFER_TOKEN_CHUNK_SIZE;
                  zzinf_tokens = (int *) realloc(zzinf_tokens,
                                                                         zzinf_token_buffer_size*sizeof(int));
                  if ( zzinf_tokens == NULL )
                  {
                        fprintf(stderr, "cannot allocate lookahead token buffer (%d tokens)\n",
                                    zzinf_token_buffer_size);
                        exit(PCCTS_EXIT_FAILURE);
                  }
            zzinf_line = (int *) realloc(zzinf_line,
                                         zzinf_token_buffer_size*sizeof(int));
            if ( zzinf_line == NULL )
            {
                fprintf(stderr, "cannot allocate lookahead line buffer (%d ints)\n",
                        zzinf_token_buffer_size);
                exit(PCCTS_EXIT_FAILURE);
                  }

            }
            while ( (zzinf_text_buffer_index+strlen(NLATEXT)+1) >= zzinf_text_buffer_size )
            {
                  zzinf_text_buffer_size += ZZINF_BUFFER_TEXT_CHUNK_SIZE;
                  zzinf_text_buffer = (char *) realloc(zzinf_text_buffer,
                                                                         zzinf_text_buffer_size);
                  if ( zzinf_text_buffer == NULL )
                  {
                        fprintf(stderr,   "cannot allocate lookahead text buffer (%d bytes)\n",
                                    zzinf_text_buffer_size);
                        exit(PCCTS_EXIT_FAILURE);
                  }
            }
            /* record token and text and line of input symbol */
            tok = zzinf_tokens[zzinf_lap] = NLA;
            strcpy(&zzinf_text_buffer[zzinf_text_buffer_index], NLATEXT);
            zzinf_text_buffer_index += strlen(NLATEXT)+1;
        zzinf_line[zzinf_lap] = line;
            zzinf_lap++;
      } while (tok!=zzEOF_TOKEN);
      zzinf_labase = 0;
      zzinf_last = zzinf_lap-1;

      /* allocate ptrs to text of ith token */
      zzinf_text = (char **) calloc(zzinf_last+1,sizeof(char *));
      if ( zzinf_text == NULL )
      {
            fprintf(stderr,   "cannot allocate lookahead text buffer (%d)\n",
                        zzinf_text_buffer_size);
            exit(PCCTS_EXIT_FAILURE);                                                           
      }                                                                             
      zzinf_text_buffer_index = 0;
      zzinf_lap = 0;
      /* set ptrs so that zzinf_text[i] is the text of the ith token found on input */
      while (zzinf_lap<=zzinf_last)
      {
          zzinf_text[zzinf_lap++] = &zzinf_text_buffer[zzinf_text_buffer_index];
            zzinf_text_buffer_index += strlen(&zzinf_text_buffer[zzinf_text_buffer_index])+1;
      }
}
#endif

int
#ifdef __USE_PROTOS
_zzsetmatch(SetWordType *e, char **zzBadText, char **zzMissText,
                  int *zzMissTok, int *zzBadTok,
                  SetWordType **zzMissSet,
                  SetWordType *zzTokclassErrset /* MR23 */)
#else
_zzsetmatch(e, zzBadText, zzMissText, zzMissTok, zzBadTok, zzMissSet, zzTokclassErrset /* MR23 */)
SetWordType *e;
char **zzBadText;
char **zzMissText;
int *zzMissTok, *zzBadTok;
SetWordType **zzMissSet;
SetWordType *zzTokclassErrset;
#endif
{
#ifdef DEMAND_LOOK
#ifdef LL_K
      if ( zzdirty==LL_K ) {zzCONSUME;}
#else
      if ( zzdirty ) {zzCONSUME;}
#endif
#endif
      if ( !zzset_el((unsigned)LA(1), e) ) {
            *zzBadText = LATEXT(1); *zzMissText=NULL;
            *zzMissTok= 0; *zzBadTok=LA(1);
            *zzMissSet=zzTokclassErrset; /* MR23 */
            return 0;
      }
      zzMakeAttr           /* MR14 Ger Hobbelt (hobbelt@axa.nl) */
#ifdef DEMAND_LOOK
#ifdef LL_K
      zzdirty++;
    zzlabase++;          /* MR14 Ger Hobbelt (hobbelt@axa.nl) */
#else
      zzdirty = 1;
#endif
#endif
      return 1;
}

int
#ifdef __USE_PROTOS
_zzmatch_wdfltsig(int tokenWanted, SetWordType *whatFollows)
#else
_zzmatch_wdfltsig(tokenWanted, whatFollows)
int tokenWanted;
SetWordType *whatFollows;
#endif
{
#ifdef DEMAND_LOOK
#ifdef LL_K
      if ( zzdirty==LL_K ) {
                  zzCONSUME;
      }
#else
      if ( zzdirty ) {zzCONSUME;}
#endif
#endif

      if ( LA(1)!=tokenWanted )
      {
        zzSyntaxErrCount++;     /* MR11 */
            fprintf(stderr,
                        "line %d: syntax error at \"%s\" missing %s\n",
                        zzline,
                        (LA(1)==zzEOF_TOKEN)?"<eof>":(char *)LATEXT(1),
                        zztokens[tokenWanted]);
            zzconsumeUntil( whatFollows );
            return 0;
      }
      else {
            zzMakeAttr                                
#ifdef DEMAND_LOOK
#ifdef LL_K
            zzdirty++;
            zzlabase++;
#else
            zzdirty = 1;
#endif
#else
/*          zzCONSUME;         consume if not demand lookahead */
#endif
            return 1;
      }
}

int
#ifdef __USE_PROTOS
_zzsetmatch_wdfltsig(SetWordType *tokensWanted,
                               int tokenTypeOfSet,
                               SetWordType *whatFollows)
#else
_zzsetmatch_wdfltsig(tokensWanted, tokenTypeOfSet, whatFollows)
SetWordType *tokensWanted;
int tokenTypeOfSet;
SetWordType *whatFollows;
#endif
{
#ifdef DEMAND_LOOK
#ifdef LL_K
      if ( zzdirty==LL_K ) {zzCONSUME;}
#else
      if ( zzdirty ) {zzCONSUME;}
#endif
#endif
      if ( !zzset_el((unsigned)LA(1), tokensWanted) )
      {
        zzSyntaxErrCount++;     /* MR11 */
            fprintf(stderr,
                        "line %d: syntax error at \"%s\" missing %s\n",
                        zzline,
                        (LA(1)==zzEOF_TOKEN)?"<eof>":(char *)LATEXT(1),
                        zztokens[tokenTypeOfSet]);
            zzconsumeUntil( whatFollows );
            return 0;
      }
      else {
            zzMakeAttr
#ifdef DEMAND_LOOK
#ifdef LL_K
            zzdirty++;
            zzlabase++;
#else
            zzdirty = 1;
#endif
#else
/*          zzCONSUME;        consume if not demand lookahead */
#endif
            return 1;
      }
}

int
#ifdef __USE_PROTOS
_zzsetmatch_wsig(SetWordType *e)
#else
_zzsetmatch_wsig(e)
SetWordType *e;
#endif
{
#ifdef DEMAND_LOOK
#ifdef LL_K
      if ( zzdirty==LL_K ) {zzCONSUME;}
#else
      if ( zzdirty ) {zzCONSUME;}
#endif
#endif
      if ( !zzset_el((unsigned)LA(1), e) ) return 0;
      zzMakeAttr           /* MR14 Ger Hobbelt (hobbelt@axa.nl) */
#ifdef DEMAND_LOOK
#ifdef LL_K
      zzdirty++;
    zzlabase++;          /* MR14 Ger Hobbelt (hobbelt@axa.nl) */
#else
      zzdirty = 1;
#endif
#endif
      return 1;
}

#ifdef USER_ZZMODE_STACK
static int  zzmstk[ZZMAXSTK] = { -1 };
static int  zzmdep = 0;
static char zzmbuf[70];

void
#ifdef __USE_PROTOS
zzmpush( int m )
#else
zzmpush( m )
int m;
#endif
{
   if(zzmdep == ZZMAXSTK - 1) {
     sprintf(zzmbuf, "Mode stack overflow ");
     zzerr(zzmbuf);
   } else {
     zzmstk[zzmdep++] = zzauto;
     zzmode(m);
   }
}

void
#ifdef __USE_PROTOS
zzmpop( void )
#else
zzmpop( )
#endif
{
   if(zzmdep == 0)
   {  sprintf(zzmbuf, "Mode stack underflow ");
      zzerr(zzmbuf);
   }
   else
   {  zzmdep--;
      zzmode(zzmstk[zzmdep]);
   }
}

void
#ifdef __USE_PROTOS
zzsave_mode_stack( int modeStack[], int *modeLevel )
#else
zzsave_mode_stack( modeStack, modeLevel )
int modeStack[];
int *modeLevel;
#endif
{
  int i;
  memcpy(modeStack, zzmstk, sizeof(zzmstk));
  *modeLevel = zzmdep;
  zzmdep = 0;

  return;
}

void
#ifdef __USE_PROTOS
zzrestore_mode_stack( int modeStack[], int *modeLevel )
#else
zzrestore_mode_stack( modeStack, modeLevel )
int modeStack[];
int *modeLevel;
#endif
{
  int i;

  memcpy(zzmstk, modeStack, sizeof(zzmstk));
  zzmdep = *modeLevel;

  return;
}
#endif /* USER_ZZMODE_STACK */

#ifdef __USE_PROTOS
void zzTraceReset(void)
#else
void zzTraceReset()
#endif
{
#ifdef zzTRACE_RULES
  zzTraceOptionValue=zzTraceOptionValueDefault;
  zzTraceGuessOptionValue=1;
  zzTraceCurrentRuleName=NULL;
  zzTraceDepth=0;
#endif
}

#ifdef __USE_PROTOS
void zzTraceGuessFail(void)
#else
void zzTraceGuessFail()
#endif
{

#ifdef zzTRACE_RULES
#ifdef ZZCAN_GUESS

  int   doIt=0;

  if (zzTraceOptionValue <= 0) {
    doIt=0;
  } else if (zzguessing && zzTraceGuessOptionValue <= 0) {
    doIt=0;
  } else {
    doIt=1;
  };

  if (doIt) {
    fprintf(stderr,"guess failed\n");
  };
#endif
#endif
}

/* zzTraceOption:
     zero value turns off trace
*/

#ifdef __USE_PROTOS
void zzTraceIn(char * rule)
#else
void zzTraceIn(rule)
  char  *rule;
#endif
{
#ifdef zzTRACE_RULES

  int           doIt=0;

  zzTraceDepth++;
  zzTraceCurrentRuleName=rule;

  if (zzTraceOptionValue <= 0) {
    doIt=0;
#ifdef ZZCAN_GUESS
  } else if (zzguessing && zzTraceGuessOptionValue <= 0) {
    doIt=0;
#endif
  } else {
    doIt=1;
  };

  if (doIt) {
    fprintf(stderr,"enter rule %s {\"%s\"} depth %d",
            rule,
            LA(1)==1 ? "@" : (char *) LATEXT(1),    /* MR19 */
            zzTraceDepth);
#ifdef ZZCAN_GUESS
    if (zzguessing) fprintf(stderr," guessing");
#endif
    fprintf(stderr,"\n");
  };
#endif
  return;
}

#ifdef __USE_PROTOS
void zzTraceOut(char * rule)
#else
void zzTraceOut(rule)
  char  *rule;
#endif
{
#ifdef zzTRACE_RULES
  int       doIt=0;

  zzTraceDepth--;

  if (zzTraceOptionValue <= 0) {
    doIt=0;
#ifdef ZZCAN_GUESS
  } else if (zzguessing && zzTraceGuessOptionValue <= 0) {
    doIt=0;
#endif
  } else {
    doIt=1;
  };

  if (doIt) {
    fprintf(stderr,"exit rule %s {\"%s\"} depth %d",
            rule,
            LA(1)==1 ? "@" : (char *) LATEXT(1), /* MR19 */
            zzTraceDepth+1);
#ifdef ZZCAN_GUESS
    if (zzguessing) fprintf(stderr," guessing");
#endif
    fprintf(stderr,"\n");
  };
#endif
}

#ifdef __USE_PROTOS
int zzTraceOption(int delta)
#else
int zzTraceOption(delta)
  int   delta;
#endif
{
#ifdef zzTRACE_RULES
    int     prevValue=zzTraceOptionValue;

    zzTraceOptionValue=zzTraceOptionValue+delta;

    if (zzTraceCurrentRuleName != NULL) {
      if (prevValue <= 0 && zzTraceOptionValue > 0) {
        fprintf(stderr,"trace enabled in rule %s depth %d\n",
                                            zzTraceCurrentRuleName,zzTraceDepth);
      };
      if (prevValue > 0 && zzTraceOptionValue <= 0) {
        fprintf(stderr,"trace disabled in rule %s depth %d\n",
                                            zzTraceCurrentRuleName,zzTraceDepth);
      };
    };
    return  prevValue;
#else
    return 0;
#endif
}

#ifdef __USE_PROTOS
int zzTraceGuessOption(int delta)
#else
int zzTraceGuessOption(delta)
  int   delta;
#endif
{
#ifdef zzTRACE_RULES
#ifdef ZZCAN_GUESS
    int     prevValue=zzTraceGuessOptionValue;

    zzTraceGuessOptionValue=zzTraceGuessOptionValue+delta;

    if (zzTraceCurrentRuleName != NULL) {
      if (prevValue <= 0 && zzTraceGuessOptionValue > 0) {
        fprintf(stderr,"guess trace enabled in rule %s depth %d\n",
                                                zzTraceCurrentRuleName,zzTraceDepth);
      };
      if (prevValue > 0 && zzTraceGuessOptionValue <= 0) {
        fprintf(stderr,"guess trace disabled in rule %s depth %d\n",
                                                zzTraceCurrentRuleName,zzTraceDepth);
      };
    };
    return prevValue;
#else
    return 0;
#endif
#else
    return 0;
#endif
}

#endif /* ERR_H */

Generated by  Doxygen 1.6.0   Back to index