From 9d480f1c86753e4ca2ef016737b9e7e39782e58b Mon Sep 17 00:00:00 2001 From: mingodad Date: Tue, 1 Oct 2024 11:22:18 +0200 Subject: [PATCH 1/4] Moved all globals/static to a structure --- src/buf.c | 4 +- src/ccl.c | 92 ++-- src/dfa.c | 330 ++++++------- src/ecs.c | 24 +- src/filter.c | 28 +- src/flexdef.h | 305 +++++++++--- src/gen.c | 480 +++++++++--------- src/main.c | 1252 ++++++++++++++++++++++++----------------------- src/misc.c | 98 ++-- src/nfa.c | 238 ++++----- src/options.c | 2 +- src/options.h | 2 +- src/parse.y | 414 ++++++++-------- src/regex.c | 4 +- src/scan.l | 466 +++++++++--------- src/scanflags.c | 28 +- src/skeletons.c | 56 +-- src/sym.c | 50 +- src/tables.h | 6 +- src/tblcmp.c | 294 +++++------ src/yylex.c | 34 +- 21 files changed, 2196 insertions(+), 2011 deletions(-) diff --git a/src/buf.c b/src/buf.c index ea6dd98ae..42f803a46 100644 --- a/src/buf.c +++ b/src/buf.c @@ -46,8 +46,8 @@ */ /* global buffers. */ -struct Buf userdef_buf; /**< for user #definitions triggered by cmd-line. */ -struct Buf top_buf; /**< contains %top code. String buffer. */ +//struct Buf userdef_buf; /**< for user #definitions triggered by cmd-line. */ +//struct Buf top_buf; /**< contains %top code. String buffer. */ /* Append a "%s" formatted string to a string buffer */ struct Buf *buf_prints (struct Buf *buf, const char *fmt, const char *s) diff --git a/src/ccl.c b/src/ccl.c index 55e4dbb35..bbff2846d 100644 --- a/src/ccl.c +++ b/src/ccl.c @@ -39,14 +39,14 @@ ccl_contains (const int cclp, const int ch) { int ind, len, i; - len = ccllen[cclp]; - ind = cclmap[cclp]; + len = gv->ccllen[cclp]; + ind = gv->cclmap[cclp]; for (i = 0; i < len; ++i) - if (ccltbl[ind + i] == ch) - return !cclng[cclp]; + if (gv->ccltbl[ind + i] == ch) + return !gv->cclng[cclp]; - return cclng[cclp]; + return gv->cclng[cclp]; } @@ -58,39 +58,39 @@ void ccladd (int cclp, int ch) check_char (ch); - len = ccllen[cclp]; - ind = cclmap[cclp]; + len = gv->ccllen[cclp]; + ind = gv->cclmap[cclp]; /* check to see if the character is already in the ccl */ for (i = 0; i < len; ++i) - if (ccltbl[ind + i] == ch) + if (gv->ccltbl[ind + i] == ch) return; /* mark newlines */ - if (ch == nlch) - ccl_has_nl[cclp] = true; + if (ch == gv->nlch) + gv->ccl_has_nl[cclp] = true; newpos = ind + len; /* For a non-last cclp, expanding the set will overflow and overwrite a * char in the next cclp. * FIXME: Need another allocation scheme for ccl's. */ - if (cclp != lastccl) { + if (cclp != gv->lastccl) { flexfatal(_("internal error: trying to add a char to a non-last ccl.\n")); } - if (newpos >= current_max_ccl_tbl_size) { - current_max_ccl_tbl_size += MAX_CCL_TBL_SIZE_INCREMENT; + if (newpos >= gv->current_max_ccl_tbl_size) { + gv->current_max_ccl_tbl_size += MAX_CCL_TBL_SIZE_INCREMENT; - ++num_reallocs; + ++gv->num_reallocs; - ccltbl = reallocate_Character_array (ccltbl, - current_max_ccl_tbl_size); + gv->ccltbl = reallocate_Character_array (gv->ccltbl, + gv->current_max_ccl_tbl_size); } - ccllen[cclp] = len + 1; - ccltbl[newpos] = (unsigned char) ch; + gv->ccllen[cclp] = len + 1; + gv->ccltbl[newpos] = (unsigned char) ch; } /* dump_cclp - same thing as list_character_set, but for cclps. */ @@ -101,7 +101,7 @@ static void dump_cclp (FILE* file, int cclp) putc ('[', file); - for (i = 0; i < ctrl.csize; ++i) { + for (i = 0; i < gv->ctrl.csize; ++i) { if (ccl_contains(cclp, i)){ int start_char = i; @@ -109,7 +109,7 @@ static void dump_cclp (FILE* file, int cclp) fputs (readable_form (i), file); - while (++i < ctrl.csize && ccl_contains(cclp,i)) ; + while (++i < gv->ctrl.csize && ccl_contains(cclp,i)) ; if (i - 1 > start_char) /* this was a run */ @@ -138,7 +138,7 @@ ccl_set_diff (int a, int b) * adding each char in a that is not in b. * (This could be O(n^2), but n is small and bounded.) */ - for ( ch = 0; ch < ctrl.csize; ++ch ) + for ( ch = 0; ch < gv->ctrl.csize; ++ch ) if (ccl_contains (a, ch) && !ccl_contains(b, ch)) ccladd (d, ch); @@ -166,12 +166,12 @@ ccl_set_union (int a, int b) d = cclinit(); /* Add all of a */ - for (i = 0; i < ccllen[a]; ++i) - ccladd (d, ccltbl[cclmap[a] + i]); + for (i = 0; i < gv->ccllen[a]; ++i) + ccladd (d, gv->ccltbl[gv->cclmap[a] + i]); /* Add all of b */ - for (i = 0; i < ccllen[b]; ++i) - ccladd (d, ccltbl[cclmap[b] + i]); + for (i = 0; i < gv->ccllen[b]; ++i) + ccladd (d, gv->ccltbl[gv->cclmap[b] + i]); /* debug */ if (0){ @@ -192,22 +192,22 @@ ccl_set_union (int a, int b) int cclinit (void) { - if (++lastccl >= current_maxccls) { - current_maxccls += MAX_CCLS_INCREMENT; + if (++gv->lastccl >= gv->current_maxccls) { + gv->current_maxccls += MAX_CCLS_INCREMENT; - ++num_reallocs; + ++gv->num_reallocs; - cclmap = - reallocate_integer_array (cclmap, current_maxccls); - ccllen = - reallocate_integer_array (ccllen, current_maxccls); - cclng = reallocate_integer_array (cclng, current_maxccls); - ccl_has_nl = reallocate_array(ccl_has_nl, current_maxccls, sizeof(char)); + gv->cclmap = + reallocate_integer_array (gv->cclmap, gv->current_maxccls); + gv->ccllen = + reallocate_integer_array (gv->ccllen, gv->current_maxccls); + gv->cclng = reallocate_integer_array (gv->cclng, gv->current_maxccls); + gv->ccl_has_nl = reallocate_array(gv->ccl_has_nl, gv->current_maxccls, sizeof(char)); } - if (lastccl == 1) + if (gv->lastccl == 1) /* we're making the first ccl */ - cclmap[lastccl] = 0; + gv->cclmap[gv->lastccl] = 0; else /* The new pointer is just past the end of the last ccl. @@ -215,14 +215,14 @@ int cclinit (void) * ccl, adding the length of the ccl to the cclmap pointer * will produce a cursor to the first free space. */ - cclmap[lastccl] = - cclmap[lastccl - 1] + ccllen[lastccl - 1]; + gv->cclmap[gv->lastccl] = + gv->cclmap[gv->lastccl - 1] + gv->ccllen[gv->lastccl - 1]; - ccllen[lastccl] = 0; - cclng[lastccl] = 0; /* ccl's start out life un-negated */ - ccl_has_nl[lastccl] = false; + gv->ccllen[gv->lastccl] = 0; + gv->cclng[gv->lastccl] = 0; /* ccl's start out life un-negated */ + gv->ccl_has_nl[gv->lastccl] = false; - return lastccl; + return gv->lastccl; } @@ -230,8 +230,8 @@ int cclinit (void) void cclnegate (int cclp) { - cclng[cclp] = 1; - ccl_has_nl[cclp] = !ccl_has_nl[cclp]; + gv->cclng[cclp] = 1; + gv->ccl_has_nl[cclp] = !gv->ccl_has_nl[cclp]; } @@ -248,7 +248,7 @@ void list_character_set (FILE *file, int cset[]) putc ('[', file); - for (i = 0; i < ctrl.csize; ++i) { + for (i = 0; i < gv->ctrl.csize; ++i) { if (cset[i]) { int start_char = i; @@ -256,7 +256,7 @@ void list_character_set (FILE *file, int cset[]) fputs (readable_form (i), file); - while (++i < ctrl.csize && cset[i]) ; + while (++i < gv->ctrl.csize && cset[i]) ; if (i - 1 > start_char) /* this was a run */ diff --git a/src/dfa.c b/src/dfa.c index ed1af9343..6170fba2e 100644 --- a/src/dfa.c +++ b/src/dfa.c @@ -52,22 +52,22 @@ static int symfollowset(int[], int, int, int[]); static void check_for_backing_up(int ds, int state[]) { - if ((reject && !dfaacc[ds].dfaacc_set) || (!reject && !dfaacc[ds].dfaacc_state)) { /* state is non-accepting */ - ++num_backing_up; + if ((gv->reject && !gv->dfaacc[ds].dfaacc_set) || (!gv->reject && !gv->dfaacc[ds].dfaacc_state)) { /* state is non-accepting */ + ++gv->num_backing_up; - if (env.backing_up_report) { - fprintf (ctrl.backing_up_file, + if (gv->env.backing_up_report) { + fprintf (gv->ctrl.backing_up_file, _("State #%d is non-accepting -\n"), ds); /* identify the state */ - dump_associated_rules (ctrl.backing_up_file, ds); + dump_associated_rules (gv->ctrl.backing_up_file, ds); /* Now identify it further using the out- and * jam-transitions. */ - dump_transitions (ctrl.backing_up_file, state); + dump_transitions (gv->ctrl.backing_up_file, state); - putc ('\n', ctrl.backing_up_file); + putc ('\n', gv->ctrl.backing_up_file); } } } @@ -101,10 +101,10 @@ static void check_trailing_context(int *nfa_states, int num_states, int *accset, for (i = 1; i <= num_states; ++i) { int ns = nfa_states[i]; - int type = state_type[ns]; - int ar = assoc_rule[ns]; + int type = gv->state_type[ns]; + int ar = gv->assoc_rule[ns]; - if (type == STATE_NORMAL || rule_type[ar] != RULE_VARIABLE) { /* do nothing */ + if (type == STATE_NORMAL || gv->rule_type[ar] != RULE_VARIABLE) { /* do nothing */ } else if (type == STATE_TRAILING_CONTEXT) { @@ -118,7 +118,7 @@ static void check_trailing_context(int *nfa_states, int num_states, int *accset, if (accset[j] & YY_TRAILING_HEAD_MASK) { line_warning (_ ("dangerous trailing context"), - rule_linenum[ar]); + gv->rule_linenum[ar]); return; } } @@ -138,11 +138,11 @@ static void dump_associated_rules(FILE *file, int ds) int i, j; int num_associated_rules = 0; int rule_set[MAX_ASSOC_RULES + 1]; - int *dset = dss[ds]; - int size = dfasiz[ds]; + int *dset = gv->dss[ds]; + int size = gv->dfasiz[ds]; for (i = 1; i <= size; ++i) { - int rule_num = rule_linenum[assoc_rule[dset[i]]]; + int rule_num = gv->rule_linenum[gv->assoc_rule[dset[i]]]; for (j = 1; j <= num_associated_rules; ++j) if (rule_num == rule_set[j]) @@ -186,8 +186,8 @@ static void dump_transitions(FILE *file, int state[]) int i, ec; int out_char_set[CSIZE]; - for (i = 0; i < ctrl.csize; ++i) { - ec = ABS (ecgroup[i]); + for (i = 0; i < gv->ctrl.csize; ++i) { + ec = ABS (gv->ecgroup[i]); out_char_set[i] = state[ec]; } @@ -196,7 +196,7 @@ static void dump_transitions(FILE *file, int state[]) list_character_set (file, out_char_set); /* now invert the members of the set to get the jam transitions */ - for (i = 0; i < ctrl.csize; ++i) + for (i = 0; i < gv->ctrl.csize; ++i) out_char_set[i] = !out_char_set[i]; fprintf (file, _("\n jam-transitions: EOF ")); @@ -232,42 +232,42 @@ static int *epsclosure(int *t, int *ns_addr, int accset[], int *nacc_addr, int * int stkpos, ns, tsp; int numstates = *ns_addr, nacc, hashval, transsym, nfaccnum; int stkend, nstate; - static int did_stk_init = false, *stk; + //static int did_stk_init = false, *stk; #define MARK_STATE(state) \ -do{ trans1[state] = trans1[state] - MARKER_DIFFERENCE;} while(0) +do{ gv->trans1[state] = gv->trans1[state] - MARKER_DIFFERENCE;} while(0) -#define IS_MARKED(state) (trans1[state] < 0) +#define IS_MARKED(state) (gv->trans1[state] < 0) #define UNMARK_STATE(state) \ -do{ trans1[state] = trans1[state] + MARKER_DIFFERENCE;} while(0) +do{ gv->trans1[state] = gv->trans1[state] + MARKER_DIFFERENCE;} while(0) #define CHECK_ACCEPT(state) \ do{ \ -nfaccnum = accptnum[state]; \ +nfaccnum = gv->accptnum[state]; \ if ( nfaccnum != NIL ) \ accset[++nacc] = nfaccnum; \ }while(0) #define DO_REALLOCATION() \ do { \ -current_max_dfa_size += MAX_DFA_SIZE_INCREMENT; \ -++num_reallocs; \ -t = reallocate_integer_array( t, current_max_dfa_size ); \ -stk = reallocate_integer_array( stk, current_max_dfa_size ); \ +gv->current_max_dfa_size += MAX_DFA_SIZE_INCREMENT; \ +++gv->num_reallocs; \ +t = reallocate_integer_array( t, gv->current_max_dfa_size ); \ +gv->stk = reallocate_integer_array( gv->stk, gv->current_max_dfa_size ); \ }while(0) \ #define PUT_ON_STACK(state) \ do { \ -if ( ++stkend >= current_max_dfa_size ) \ +if ( ++stkend >= gv->current_max_dfa_size ) \ DO_REALLOCATION(); \ -stk[stkend] = state; \ +gv->stk[stkend] = state; \ MARK_STATE(state); \ }while(0) #define ADD_STATE(state) \ do { \ -if ( ++numstates >= current_max_dfa_size ) \ +if ( ++numstates >= gv->current_max_dfa_size ) \ DO_REALLOCATION(); \ t[numstates] = state; \ hashval += state; \ @@ -277,14 +277,14 @@ hashval += state; \ do { \ PUT_ON_STACK(state); \ CHECK_ACCEPT(state); \ -if ( nfaccnum != NIL || transchar[state] != SYM_EPSILON ) \ +if ( nfaccnum != NIL || gv->transchar[state] != SYM_EPSILON ) \ ADD_STATE(state); \ }while(0) - if (!did_stk_init) { - stk = allocate_integer_array (current_max_dfa_size); - did_stk_init = true; + if (!gv->did_stk_init) { + gv->stk = allocate_integer_array (gv->current_max_dfa_size); + gv->did_stk_init = true; } nacc = stkend = hashval = 0; @@ -303,17 +303,17 @@ ADD_STATE(state); \ } for (stkpos = 1; stkpos <= stkend; ++stkpos) { - ns = stk[stkpos]; - transsym = transchar[ns]; + ns = gv->stk[stkpos]; + transsym = gv->transchar[ns]; if (transsym == SYM_EPSILON) { - tsp = trans1[ns] + MARKER_DIFFERENCE; + tsp = gv->trans1[ns] + MARKER_DIFFERENCE; if (tsp != NO_TRANSITION) { if (!IS_MARKED (tsp)) STACK_STATE (tsp); - tsp = trans2[ns]; + tsp = gv->trans2[ns]; if (tsp != NO_TRANSITION && !IS_MARKED (tsp)) @@ -325,8 +325,8 @@ ADD_STATE(state); \ /* Clear out "visit" markers. */ for (stkpos = 1; stkpos <= stkend; ++stkpos) { - if (IS_MARKED (stk[stkpos])) - UNMARK_STATE (stk[stkpos]); + if (IS_MARKED (gv->stk[stkpos])) + UNMARK_STATE (gv->stk[stkpos]); else flexfatal (_ ("consistency check failed in epsclosure()")); @@ -344,23 +344,23 @@ ADD_STATE(state); \ void increase_max_dfas (void) { - current_max_dfas += MAX_DFAS_INCREMENT; + gv->current_max_dfas += MAX_DFAS_INCREMENT; - ++num_reallocs; + ++gv->num_reallocs; - base = reallocate_integer_array (base, current_max_dfas); - def = reallocate_integer_array (def, current_max_dfas); - dfasiz = reallocate_integer_array (dfasiz, current_max_dfas); - accsiz = reallocate_integer_array (accsiz, current_max_dfas); - dhash = reallocate_integer_array (dhash, current_max_dfas); - dss = reallocate_int_ptr_array (dss, current_max_dfas); - dfaacc = reallocate_array(dfaacc, current_max_dfas, + gv->base = reallocate_integer_array (gv->base, gv->current_max_dfas); + gv->def = reallocate_integer_array (gv->def, gv->current_max_dfas); + gv->dfasiz = reallocate_integer_array (gv->dfasiz, gv->current_max_dfas); + gv->accsiz = reallocate_integer_array (gv->accsiz, gv->current_max_dfas); + gv->dhash = reallocate_integer_array (gv->dhash, gv->current_max_dfas); + gv->dss = reallocate_int_ptr_array (gv->dss, gv->current_max_dfas); + gv->dfaacc = reallocate_array(gv->dfaacc, gv->current_max_dfas, sizeof(union dfaacc_union)); - if (nultrans) - nultrans = - reallocate_integer_array (nultrans, - current_max_dfas); + if (gv->nultrans) + gv->nultrans = + reallocate_integer_array (gv->nultrans, + gv->current_max_dfas); } @@ -400,8 +400,8 @@ size_t ntod (void) /* accset needs to be large enough to hold all of the rules present * in the input, *plus* their YY_TRAILING_HEAD_MASK variants. */ - accset = allocate_integer_array ((num_rules + 1) * 2); - nset = allocate_integer_array (current_max_dfa_size); + accset = allocate_integer_array ((gv->num_rules + 1) * 2); + nset = allocate_integer_array (gv->current_max_dfa_size); /* The "todo" queue is represented by the head, which is the DFA * state currently being processed, and the "next", which is the @@ -411,16 +411,16 @@ size_t ntod (void) */ todo_head = todo_next = 0; - for (i = 0; i <= ctrl.csize; ++i) { + for (i = 0; i <= gv->ctrl.csize; ++i) { duplist[i] = NIL; symlist[i] = false; } - for (i = 0; i <= num_rules; ++i) + for (i = 0; i <= gv->num_rules; ++i) accset[i] = NIL; - if (env.trace) { - dumpnfa (scset[1]); + if (gv->env.trace) { + dumpnfa (gv->scset[1]); fputs (_("\n\nDFA Dump:\n\n"), stderr); } @@ -461,30 +461,30 @@ size_t ntod (void) * New way: we will only use NUL table for fulltbl, because the * scanner will use an integer instead of YY_CHAR as noted above */ - if (ctrl.fulltbl && ecgroup[0] == numecs && is_power_of_2(numecs)) - nultrans = allocate_integer_array (current_max_dfas); + if (gv->ctrl.fulltbl && gv->ecgroup[0] == gv->numecs && is_power_of_2(gv->numecs)) + gv->nultrans = allocate_integer_array (gv->current_max_dfas); - if (ctrl.fullspd) { - for (i = 0; i <= numecs; ++i) + if (gv->ctrl.fullspd) { + for (i = 0; i <= gv->numecs; ++i) state[i] = 0; place_state (state, 0, 0); - dfaacc[0].dfaacc_state = 0; + gv->dfaacc[0].dfaacc_state = 0; } - else if (ctrl.fulltbl) { - if (nultrans) + else if (gv->ctrl.fulltbl) { + if (gv->nultrans) /* We won't be including NUL's transitions in the * table, so build it for entries from 0 .. numecs - 1. */ - num_full_table_rows = numecs; + num_full_table_rows = gv->numecs; else /* Take into account the fact that we'll be including * the NUL entries in the transition table. Build it * from 0 .. numecs. */ - num_full_table_rows = numecs + 1; + num_full_table_rows = gv->numecs + 1; /* Begin generating yy_nxt[][] * This spans the entire LONG function. @@ -493,7 +493,7 @@ size_t ntod (void) * we'll wait until we can calculate yynxt_tbl->td_hilen. */ yynxt_tbl = calloc(1, sizeof (struct yytbl_data)); - + yytbl_data_init (yynxt_tbl, YYTD_ID_NXT); yynxt_tbl->td_hilen = 1; yynxt_tbl->td_lolen = (flex_uint32_t) num_full_table_rows; @@ -509,7 +509,7 @@ size_t ntod (void) out_dec ("m4_define([[M4_HOOK_NXT_ROWS]], [[%d]])", num_full_table_rows); outn ("m4_define([[M4_HOOK_NXT_BODY]], [[m4_dnl"); outn ("M4_HOOK_TABLE_OPENER"); - if (gentables) + if (gv->gentables) outn ("M4_HOOK_TABLE_OPENER"); /* Generate 0 entries for state #0. */ @@ -518,7 +518,7 @@ size_t ntod (void) yynxt_data[yynxt_curr++] = 0; } - if (gentables) { + if (gv->gentables) { dataflush (); outn ("M4_HOOK_TABLE_CONTINUE"); } @@ -526,7 +526,7 @@ size_t ntod (void) /* Create the first states. */ - num_start_states = lastsc * 2; + num_start_states = gv->lastsc * 2; for (i = 1; i <= num_start_states; ++i) { numstates = 1; @@ -536,31 +536,31 @@ size_t ntod (void) * one for the case when we're not. */ if (i % 2 == 1) - nset[numstates] = scset[(i / 2) + 1]; + nset[numstates] = gv->scset[(i / 2) + 1]; else nset[numstates] = - mkbranch (scbol[i / 2], scset[i / 2]); + mkbranch (gv->scbol[i / 2], gv->scset[i / 2]); nset = epsclosure (nset, &numstates, accset, &nacc, &hashval); if (snstods (nset, numstates, accset, nacc, hashval, &ds)) { - numas += nacc; - totnst += numstates; + gv->numas += nacc; + gv->totnst += numstates; ++todo_next; - if (variable_trailing_context_rules && nacc > 0) + if (gv->variable_trailing_context_rules && nacc > 0) check_trailing_context (nset, numstates, accset, nacc); } } - if (!ctrl.fullspd) { - if (!snstods (nset, 0, accset, 0, 0, &end_of_buffer_state)) + if (!gv->ctrl.fullspd) { + if (!snstods (nset, 0, accset, 0, 0, &gv->end_of_buffer_state)) flexfatal (_ ("could not create unique end-of-buffer state")); - ++numas; + ++gv->numas; ++num_start_states; ++todo_next; } @@ -570,20 +570,20 @@ size_t ntod (void) targptr = 0; totaltrans = 0; - for (i = 1; i <= numecs; ++i) + for (i = 1; i <= gv->numecs; ++i) state[i] = 0; ds = ++todo_head; - dset = dss[ds]; - dsize = dfasiz[ds]; + dset = gv->dss[ds]; + dsize = gv->dfasiz[ds]; - if (env.trace) + if (gv->env.trace) fprintf (stderr, _("state # %d:\n"), ds); sympartition (dset, dsize, symlist, duplist); - for (sym = 1; sym <= numecs; ++sym) { + for (sym = 1; sym <= gv->numecs; ++sym) { if (symlist[sym]) { symlist[sym] = 0; @@ -600,12 +600,12 @@ size_t ntod (void) if (snstods (nset, numstates, accset, nacc, hashval, &newds)) { - totnst = totnst + + gv->totnst = gv->totnst + numstates; ++todo_next; - numas += nacc; + gv->numas += nacc; - if (variable_trailing_context_rules && nacc > 0) + if (gv->variable_trailing_context_rules && nacc > 0) check_trailing_context (nset, numstates, @@ -615,14 +615,14 @@ size_t ntod (void) state[sym] = newds; - if (env.trace) + if (gv->env.trace) fprintf (stderr, "\t%d\t%d\n", sym, newds); targfreq[++targptr] = 1; targstate[targptr] = newds; - ++numuniq; + ++gv->numuniq; } else { @@ -633,7 +633,7 @@ size_t ntod (void) targ = state[duplist[sym]]; state[sym] = targ; - if (env.trace) + if (gv->env.trace) fprintf (stderr, "\t%d\t%d\n", sym, targ); @@ -646,7 +646,7 @@ size_t ntod (void) while (targstate[++i] != targ) ; ++targfreq[i]; - ++numdup; + ++gv->numdup; } ++totaltrans; @@ -655,17 +655,17 @@ size_t ntod (void) } - numsnpairs += totaltrans; + gv->numsnpairs += totaltrans; if (ds > num_start_states) check_for_backing_up (ds, state); - if (nultrans) { - nultrans[ds] = state[NUL_ec]; - state[NUL_ec] = 0; /* remove transition */ + if (gv->nultrans) { + gv->nultrans[ds] = state[gv->NUL_ec]; + state[gv->NUL_ec] = 0; /* remove transition */ } - if (ctrl.fulltbl) { + if (gv->ctrl.fulltbl) { /* Each time we hit here, it's another td_hilen, so we realloc. */ yynxt_tbl->td_hilen++; @@ -674,19 +674,19 @@ size_t ntod (void) yynxt_tbl->td_hilen * yynxt_tbl->td_lolen * sizeof (flex_int32_t)); - if (gentables) + if (gv->gentables) outn ("M4_HOOK_TABLE_OPENER"); /* Supply array's 0-element. */ - if (ds == end_of_buffer_state) { - mk2data (-end_of_buffer_state); + if (ds == gv->end_of_buffer_state) { + mk2data (-gv->end_of_buffer_state); yynxt_data[yynxt_curr++] = - -end_of_buffer_state; + -gv->end_of_buffer_state; } else { - mk2data (end_of_buffer_state); + mk2data (gv->end_of_buffer_state); yynxt_data[yynxt_curr++] = - end_of_buffer_state; + gv->end_of_buffer_state; } for (i = 1; i < num_full_table_rows; ++i) { @@ -698,16 +698,16 @@ size_t ntod (void) state[i] ? state[i] : -ds; } - if (gentables) { + if (gv->gentables) { dataflush (); outn ("M4_HOOK_TABLE_CONTINUE"); } } - else if (ctrl.fullspd) + else if (gv->ctrl.fullspd) place_state (state, ds, totaltrans); - else if (ds == end_of_buffer_state) + else if (ds == gv->end_of_buffer_state) /* Special case this state to make sure it does what * it's supposed to, i.e., jam on end-of-buffer. */ @@ -732,12 +732,12 @@ size_t ntod (void) } } - if (ctrl.fulltbl) { + if (gv->ctrl.fulltbl) { dataend ("M4_HOOK_TABLE_CLOSER"); outn("/* body */]])"); - if (tablesext) { + if (gv->tablesext) { yytbl_data_compress (yynxt_tbl); - if (yytbl_data_fwrite (&tableswr, yynxt_tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, yynxt_tbl) < 0) flexerror (_ ("Could not write yynxt_tbl[][]")); } @@ -747,16 +747,16 @@ size_t ntod (void) } } - else if (!ctrl.fullspd) { + else if (!gv->ctrl.fullspd) { cmptmps (); /* create compressed template entries */ /* Create tables for all the states with only one * out-transition. */ - while (onesp > 0) { - mk1tbl (onestate[onesp], onesym[onesp], - onenext[onesp], onedef[onesp]); - --onesp; + while (gv->onesp > 0) { + mk1tbl (gv->onestate[gv->onesp], gv->onesym[gv->onesp], + gv->onenext[gv->onesp], gv->onedef[gv->onesp]); + --gv->onesp; } mkdeftbl (); @@ -786,10 +786,10 @@ static int snstods(int sns[], int numstates, int accset[], int nacc, int hashval int i, j; int newds, *oldsns; - for (i = 1; i <= lastdfa; ++i) - if (hashval == dhash[i]) { - if (numstates == dfasiz[i]) { - oldsns = dss[i]; + for (i = 1; i <= gv->lastdfa; ++i) + if (hashval == gv->dhash[i]) { + if (numstates == gv->dfasiz[i]) { + oldsns = gv->dss[i]; if (!didsort) { /* We sort the states in sns so we @@ -804,26 +804,26 @@ static int snstods(int sns[], int numstates, int accset[], int nacc, int hashval break; if (j > numstates) { - ++dfaeql; + ++gv->dfaeql; *newds_addr = i; return 0; } - ++hshcol; + ++gv->hshcol; } else - ++hshsave; + ++gv->hshsave; } /* Make a new dfa. */ - if (++lastdfa >= current_max_dfas) + if (++gv->lastdfa >= gv->current_max_dfas) increase_max_dfas (); - newds = lastdfa; + newds = gv->lastdfa; - dss[newds] = allocate_integer_array (numstates + 1); + gv->dss[newds] = allocate_integer_array (numstates + 1); /* If we haven't already sorted the states in sns, we do so now, * so that future comparisons with it can be made quickly. @@ -833,21 +833,21 @@ static int snstods(int sns[], int numstates, int accset[], int nacc, int hashval qsort (&sns [1], (size_t) numstates, sizeof (sns [1]), intcmp); for (i = 1; i <= numstates; ++i) - dss[newds][i] = sns[i]; + gv->dss[newds][i] = sns[i]; - dfasiz[newds] = numstates; - dhash[newds] = hashval; + gv->dfasiz[newds] = numstates; + gv->dhash[newds] = hashval; if (nacc == 0) { - if (reject) - dfaacc[newds].dfaacc_set = NULL; + if (gv->reject) + gv->dfaacc[newds].dfaacc_set = NULL; else - dfaacc[newds].dfaacc_state = 0; + gv->dfaacc[newds].dfaacc_state = 0; - accsiz[newds] = 0; + gv->accsiz[newds] = 0; } - else if (reject) { + else if (gv->reject) { /* We sort the accepting set in increasing order so the * disambiguating rule that the first rule listed is considered * match in the event of ties will work. @@ -855,37 +855,37 @@ static int snstods(int sns[], int numstates, int accset[], int nacc, int hashval qsort (&accset [1], (size_t) nacc, sizeof (accset [1]), intcmp); - dfaacc[newds].dfaacc_set = + gv->dfaacc[newds].dfaacc_set = allocate_integer_array (nacc + 1); /* Save the accepting set for later */ for (i = 1; i <= nacc; ++i) { - dfaacc[newds].dfaacc_set[i] = accset[i]; + gv->dfaacc[newds].dfaacc_set[i] = accset[i]; - if (accset[i] <= num_rules) + if (accset[i] <= gv->num_rules) /* Who knows, perhaps a REJECT can yield * this rule. */ - rule_useful[accset[i]] = true; + gv->rule_useful[accset[i]] = true; } - accsiz[newds] = nacc; + gv->accsiz[newds] = nacc; } else { /* Find lowest numbered rule so the disambiguating rule * will work. */ - j = num_rules + 1; + j = gv->num_rules + 1; for (i = 1; i <= nacc; ++i) if (accset[i] < j) j = accset[i]; - dfaacc[newds].dfaacc_state = j; + gv->dfaacc[newds].dfaacc_state = j; - if (j <= num_rules) - rule_useful[j] = true; + if (j <= gv->num_rules) + gv->rule_useful[j] = true; } *newds_addr = newds; @@ -909,23 +909,23 @@ static int symfollowset(int ds[], int dsize, int transsym, int nset[]) for (i = 1; i <= dsize; ++i) { /* for each nfa state ns in the state set of ds */ ns = ds[i]; - sym = transchar[ns]; - tsp = trans1[ns]; + sym = gv->transchar[ns]; + tsp = gv->trans1[ns]; if (sym < 0) { /* it's a character class */ sym = -sym; - ccllist = cclmap[sym]; - lenccl = ccllen[sym]; + ccllist = gv->cclmap[sym]; + lenccl = gv->ccllen[sym]; - if (cclng[sym]) { + if (gv->cclng[sym]) { for (j = 0; j < lenccl; ++j) { /* Loop through negated character * class. */ - ch = ccltbl[ccllist + j]; + ch = gv->ccltbl[ccllist + j]; if (ch == 0) - ch = NUL_ec; + ch = gv->NUL_ec; if (ch > transsym) /* Transsym isn't in negated @@ -944,10 +944,10 @@ static int symfollowset(int ds[], int dsize, int transsym, int nset[]) else for (j = 0; j < lenccl; ++j) { - ch = ccltbl[ccllist + j]; + ch = gv->ccltbl[ccllist + j]; if (ch == 0) - ch = NUL_ec; + ch = gv->NUL_ec; if (ch > transsym) break; @@ -961,7 +961,7 @@ static int symfollowset(int ds[], int dsize, int transsym, int nset[]) else if (sym == SYM_EPSILON) { /* do nothing */ } - else if (ABS (ecgroup[sym]) == transsym) + else if (ABS (gv->ecgroup[sym]) == transsym) nset[++numstates] = tsp; bottom:; @@ -987,26 +987,26 @@ static void sympartition(int ds[], int numstates, int symlist[], int duplist[]) * we are really creating equivalence classes of equivalence classes. */ - for (i = 1; i <= numecs; ++i) { /* initialize equivalence class list */ + for (i = 1; i <= gv->numecs; ++i) { /* initialize equivalence class list */ duplist[i] = i - 1; dupfwd[i] = i + 1; } duplist[1] = NIL; - dupfwd[numecs] = NIL; + dupfwd[gv->numecs] = NIL; for (i = 1; i <= numstates; ++i) { ns = ds[i]; - tch = transchar[ns]; + tch = gv->transchar[ns]; if (tch != SYM_EPSILON) { - if (tch < -lastccl || tch >= ctrl.csize) { + if (tch < -gv->lastccl || tch >= gv->ctrl.csize) { flexfatal (_ ("bad transition character detected in sympartition()")); } if (tch >= 0) { /* character transition */ - int ec = ecgroup[tch]; + int ec = gv->ecgroup[tch]; mkechar (ec, dupfwd, duplist); symlist[ec] = 1; @@ -1015,34 +1015,34 @@ static void sympartition(int ds[], int numstates, int symlist[], int duplist[]) else { /* character class */ tch = -tch; - lenccl = ccllen[tch]; - cclp = cclmap[tch]; - mkeccl (ccltbl + cclp, lenccl, dupfwd, - duplist, numecs, NUL_ec); + lenccl = gv->ccllen[tch]; + cclp = gv->cclmap[tch]; + mkeccl (gv->ccltbl + cclp, lenccl, dupfwd, + duplist, gv->numecs, gv->NUL_ec); - if (cclng[tch]) { + if (gv->cclng[tch]) { j = 0; for (k = 0; k < lenccl; ++k) { - ich = ccltbl[cclp + k]; + ich = gv->ccltbl[cclp + k]; if (ich == 0) - ich = NUL_ec; + ich = gv->NUL_ec; for (++j; j < ich; ++j) symlist[j] = 1; } - for (++j; j <= numecs; ++j) + for (++j; j <= gv->numecs; ++j) symlist[j] = 1; } else for (k = 0; k < lenccl; ++k) { - ich = ccltbl[cclp + k]; + ich = gv->ccltbl[cclp + k]; if (ich == 0) - ich = NUL_ec; + ich = gv->NUL_ec; symlist[ich] = 1; } diff --git a/src/ecs.c b/src/ecs.c index dc68360d7..69a3ed7f0 100644 --- a/src/ecs.c +++ b/src/ecs.c @@ -40,7 +40,7 @@ void ccl2ecl (void) { int i, ich, newlen, cclp, ccls, cclmec; - for (i = 1; i <= lastccl; ++i) { + for (i = 1; i <= gv->lastccl; ++i) { /* We loop through each character class, and for each character * in the class, add the character's equivalence class to the * new "character" class we are creating. Thus when we are all @@ -49,20 +49,20 @@ void ccl2ecl (void) */ newlen = 0; - cclp = cclmap[i]; + cclp = gv->cclmap[i]; - for (ccls = 0; ccls < ccllen[i]; ++ccls) { - ich = ccltbl[cclp + ccls]; - cclmec = ecgroup[ich]; + for (ccls = 0; ccls < gv->ccllen[i]; ++ccls) { + ich = gv->ccltbl[cclp + ccls]; + cclmec = gv->ecgroup[ich]; if (cclmec > 0) { /* Note: range 1..256 is mapped to 1..255,0 */ - ccltbl[cclp + newlen] = (unsigned char) cclmec; + gv->ccltbl[cclp + newlen] = (unsigned char) cclmec; ++newlen; } } - ccllen[i] = newlen; + gv->ccllen[i] = newlen; } } @@ -116,7 +116,7 @@ void mkeccl (unsigned char ccls[], int lenccl, int fwd[], int bck[], int llsi { int cclp, oldec, newec; int cclm, i, j; - static unsigned char cclflags[CSIZE]; /* initialized to all '\0' */ + //static unsigned char cclflags[CSIZE]; /* initialized to all '\0' */ /* Note that it doesn't matter whether or not the character class is * negated. The same results will be obtained in either case. @@ -147,7 +147,7 @@ void mkeccl (unsigned char ccls[], int lenccl, int fwd[], int bck[], int llsi if (ccl_char > i) break; - if (ccl_char == i && !cclflags[j]) { + if (ccl_char == i && !gv->cclflags[j]) { /* We found an old companion of cclm * in the ccl. Link it into the new * equivalence class and flag it as @@ -158,7 +158,7 @@ void mkeccl (unsigned char ccls[], int lenccl, int fwd[], int bck[], int llsi fwd[newec] = i; newec = i; /* Set flag so we don't reprocess. */ - cclflags[j] = 1; + gv->cclflags[j] = 1; /* Get next equivalence class member. */ /* continue 2 */ @@ -189,9 +189,9 @@ void mkeccl (unsigned char ccls[], int lenccl, int fwd[], int bck[], int llsi /* Find next ccl member to process. */ - for (++cclp; cclp < lenccl && cclflags[cclp]; ++cclp) { + for (++cclp; cclp < lenccl && gv->cclflags[cclp]; ++cclp) { /* Reset "doesn't need processing" flag. */ - cclflags[cclp] = 0; + gv->cclflags[cclp] = 0; } } } diff --git a/src/filter.c b/src/filter.c index efb5f6aa7..b075a8684 100644 --- a/src/filter.c +++ b/src/filter.c @@ -29,7 +29,7 @@ static const char * check_4_gnu_m4 = /** global chain. */ -struct filter *output_chain = NULL; +//struct filter *output_chain = NULL; /* Allocate and initialize an external filter. * @param chain the current chain or NULL for new chain @@ -264,7 +264,7 @@ int filter_tee_header (struct filter *chain) fputs ("m4_define([[M4_YY_IN_HEADER]],[[]])m4_dnl\n", to_h); fprintf (to_h, "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n", - env.headerfilename != NULL ? env.headerfilename : ""); + gv->env.headerfilename != NULL ? gv->env.headerfilename : ""); } fputs (check_4_gnu_m4, to_c); @@ -273,7 +273,7 @@ int filter_tee_header (struct filter *chain) fputs ("m4_changequote([[,]])[[]]m4_dnl\n", to_c); fputs ("m4_define([[M4_YY_NOOP]])[[]]m4_dnl\n", to_c); fprintf (to_c, "m4_define( [[M4_YY_OUTFILE_NAME]],[[%s]])m4_dnl\n", - env.outfilename != NULL ? env.outfilename : ""); + gv->env.outfilename != NULL ? gv->env.outfilename : ""); while (fgets (buf, sizeof buf, stdin)) { fputs (buf, to_c); @@ -285,7 +285,7 @@ int filter_tee_header (struct filter *chain) fprintf (to_h, "\n"); /* write a fake line number. It will get fixed by the linedir filter. */ - if (ctrl.gen_line_dirs) + if (gv->ctrl.gen_line_dirs) line_directive_out (to_h, NULL, 4000); fflush (to_h); if (ferror (to_h)) @@ -300,11 +300,11 @@ int filter_tee_header (struct filter *chain) fflush (to_c); if (ferror (to_c)) lerr (_("error writing output file %s"), - env.outfilename != NULL ? env.outfilename : ""); + gv->env.outfilename != NULL ? gv->env.outfilename : ""); else if (fclose (to_c)) lerr (_("error closing output file %s"), - env.outfilename != NULL ? env.outfilename : ""); + gv->env.outfilename != NULL ? gv->env.outfilename : ""); while (wait (0) > 0) ; @@ -344,9 +344,9 @@ int filter_fix_linedirs (struct filter *chain) /* Check for directive. Note wired-in assumption: * field reference 1 is line number, 2 is filename. */ - if (ctrl.traceline_re != NULL && - ctrl.traceline_template != NULL && - regexec (®ex_linedir, buf, 3, m, 0) == 0) { + if (gv->ctrl.traceline_re != NULL && + gv->ctrl.traceline_template != NULL && + regexec (&gv->regex_linedir, buf, 3, m, 0) == 0) { char *fname; @@ -354,10 +354,10 @@ int filter_fix_linedirs (struct filter *chain) fname = regmatch_dup (&m[2], buf); if (strcmp (fname, - env.outfilename != NULL ? env.outfilename : "") + gv->env.outfilename != NULL ? gv->env.outfilename : "") == 0 || strcmp (fname, - env.headerfilename != NULL ? env.headerfilename : "") + gv->env.headerfilename != NULL ? gv->env.headerfilename : "") == 0) { char *s1, *s2; @@ -381,7 +381,7 @@ int filter_fix_linedirs (struct filter *chain) /* Adjust the line directives. */ in_gen = true; - snprintf (buf, readsz, ctrl.traceline_template, + snprintf (buf, readsz, gv->ctrl.traceline_template, lineno + 1, filename); strncat(buf, "\n", sizeof(buf)-1); } @@ -413,11 +413,11 @@ int filter_fix_linedirs (struct filter *chain) fflush (stdout); if (ferror (stdout)) lerr (_("error writing output file %s"), - env.outfilename != NULL ? env.outfilename : ""); + gv->env.outfilename != NULL ? gv->env.outfilename : ""); else if (fclose (stdout)) lerr (_("error closing output file %s"), - env.outfilename != NULL ? env.outfilename : ""); + gv->env.outfilename != NULL ? gv->env.outfilename : ""); return 0; } diff --git a/src/flexdef.h b/src/flexdef.h index adf4fd0a7..bd1fc14a9 100644 --- a/src/flexdef.h +++ b/src/flexdef.h @@ -147,16 +147,16 @@ * that can be used. This definition is currently not used. */ #define FREE_EPSILON(state) \ - (transchar[state] == SYM_EPSILON && \ - trans2[state] == NO_TRANSITION && \ - finalst[state] != state) + (gv->transchar[state] == SYM_EPSILON && \ + gv->trans2[state] == NO_TRANSITION && \ + gv->finalst[state] != state) /* Returns true if an nfa state has an epsilon out-transition character * and both slots are free */ #define SUPER_FREE_EPSILON(state) \ - (transchar[state] == SYM_EPSILON && \ - trans1[state] == NO_TRANSITION) \ + (gv->transchar[state] == SYM_EPSILON && \ + gv->trans1[state] == NO_TRANSITION) \ /* Maximum number of NFA states that can comprise a DFA state. It's real * big because if there's a lot of rules, the initial state will have a @@ -221,7 +221,7 @@ /* Enough so that if it's subtracted from an NFA state number, the result * is guaranteed to be negative. */ -#define MARKER_DIFFERENCE (maximum_mns+2) +#define MARKER_DIFFERENCE (gv->maximum_mns+2) /* Maximum number of nxt/chk pairs for non-templates. */ #define INITIAL_MAX_XPAIRS 2000 @@ -434,8 +434,8 @@ struct packtype_t { size_t width; }; -extern struct ctrl_bundle_t ctrl; -extern struct env_bundle_t env; +//extern struct ctrl_bundle_t ctrl; +//extern struct env_bundle_t env; /* Declarations for global variables. */ @@ -455,8 +455,8 @@ extern struct env_bundle_t env; * reject_really_used - same for REJECT */ -extern bool syntaxerror, eofseen; -extern int yymore_used, reject, real_reject, continued_action, in_rule; +//extern bool syntaxerror, eofseen; +//extern int yymore_used, reject, real_reject, continued_action, in_rule; /* Variables used in the flex input routines: * datapos - characters on current output line @@ -482,17 +482,17 @@ extern int yymore_used, reject, real_reject, continued_action, in_rule; * always_interactive - if true, generate an interactive scanner */ -extern int datapos, dataline, linenum; -extern int skel_ind; -extern char *infilename; -extern char *extra_type; -extern char **input_files; -extern int num_input_files; -extern char *program_name; +//extern int datapos, dataline, linenum; +//extern int skel_ind; +//extern char *infilename; +//extern char *extra_type; +//extern char **input_files; +//extern int num_input_files; +//extern char *program_name; -extern char *action_array; -extern int action_size; -extern int defs1_offset, prolog_offset, action_offset, action_index; +//extern char *action_array; +//extern int action_size; +//extern int defs1_offset, prolog_offset, action_offset, action_index; /* Variables for stack of states having only one out-transition: @@ -503,8 +503,8 @@ extern int defs1_offset, prolog_offset, action_offset, action_index; * onesp - stack pointer */ -extern int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE]; -extern int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp; +//extern int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE]; +//extern int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp; /* Variables for nfa machine data: @@ -541,16 +541,16 @@ extern int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp; * footprint - total size of tables, in bytes. */ -extern int maximum_mns, current_mns, current_max_rules; -extern int num_rules, num_eof_rules, default_rule, lastnfa; -extern int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2; -extern int *accptnum, *assoc_rule, *state_type; -extern int *rule_type, *rule_linenum; +//extern int maximum_mns, current_mns, current_max_rules; +//extern int num_rules, num_eof_rules, default_rule, lastnfa; +//extern int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2; +//extern int *accptnum, *assoc_rule, *state_type; +//extern int *rule_type, *rule_linenum; /* rule_useful[], rule_has_nl[] and ccl_has_nl[] are boolean arrays, * but allocated as char arrays for size. */ -extern char *rule_useful, *rule_has_nl, *ccl_has_nl; -extern int nlch; -extern size_t footprint; +//extern char *rule_useful, *rule_has_nl, *ccl_has_nl; +//extern int nlch; +//extern size_t footprint; /* Different types of states; values are useful as masks, as well, for @@ -561,7 +561,7 @@ extern size_t footprint; /* Global holding current type of state we're making. */ -extern int current_state_type; +//extern int current_state_type; /* Different types of rules. */ #define RULE_NORMAL 0 @@ -570,7 +570,7 @@ extern int current_state_type; /* True if the input rules include a rule with both variable-length head * and trailing context, false otherwise. */ -extern bool variable_trailing_context_rules; +//extern bool variable_trailing_context_rules; /* Variables for protos: @@ -585,8 +585,8 @@ extern bool variable_trailing_context_rules; * protsave contains the entire state array for protos */ -extern int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP]; -extern int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE]; +//extern int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP]; +//extern int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE]; /* Variables for managing equivalence classes: @@ -604,14 +604,14 @@ extern int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE]; * for the NUL character. Later we'll move this information into * the 0th element. */ -extern int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs; +//extern int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs; /* Meta-equivalence classes are indexed starting at 1, so it's possible * that they will require positions from 1 .. CSIZE, i.e., CSIZE + 1 * slots total (since the arrays are 0-based). nextecm[] and ecgroup[] * don't require the extra position since they're indexed from 1 .. CSIZE - 1. */ -extern int tecfwd[CSIZE + 1], tecbck[CSIZE + 1]; +//extern int tecfwd[CSIZE + 1], tecbck[CSIZE + 1]; /* Variables for start conditions: @@ -624,12 +624,12 @@ extern int tecfwd[CSIZE + 1], tecbck[CSIZE + 1]; * scname - start condition name */ -extern int lastsc, *scset, *scbol; +//extern int lastsc, *scset, *scbol; /* scxclu[] and sceof[] are boolean arrays, but allocated as char * arrays for size. */ -extern char *scxclu, *sceof; -extern int current_max_scs; -extern const char **scname; +//extern char *scxclu, *sceof; +//extern int current_max_scs; +//extern const char **scname; /* Variables for dfa machine data: @@ -662,18 +662,18 @@ extern const char **scname; * end_of_buffer_state - end-of-buffer dfa state number */ -extern int current_max_dfa_size, current_max_xpairs; -extern int current_max_template_xpairs, current_max_dfas; -extern int lastdfa, *nxt, *chk, *tnxt; -extern int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, - *dfasiz; -extern union dfaacc_union { - int *dfaacc_set; - int dfaacc_state; -} *dfaacc; -extern int *accsiz, *dhash, numas; -extern int numsnpairs, jambase, jamstate; -extern int end_of_buffer_state; +//extern int current_max_dfa_size, current_max_xpairs; +//extern int current_max_template_xpairs, current_max_dfas; +//extern int lastdfa, *nxt, *chk, *tnxt; +//extern int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, +// *dfasiz; +//extern union dfaacc_union { +// int *dfaacc_set; +// int dfaacc_state; +//}; *dfaacc; +//extern int *accsiz, *dhash, numas; +//extern int numsnpairs, jambase, jamstate; +//extern int end_of_buffer_state; /* Variables for ccl information: * lastccl - ccl index of the last created ccl @@ -687,9 +687,9 @@ extern int end_of_buffer_state; * ccltbl - holds the characters in each ccl - indexed by cclmap */ -extern int lastccl, *cclmap, *ccllen, *cclng, cclreuse; -extern int current_maxccls, current_max_ccl_tbl_size; -extern unsigned char *ccltbl; +//extern int lastccl, *cclmap, *ccllen, *cclng, cclreuse; +//extern int current_maxccls, current_max_ccl_tbl_size; +//extern unsigned char *ccltbl; /* Variables for miscellaneous information: @@ -713,10 +713,10 @@ extern unsigned char *ccltbl; * bol_needed - whether scanner needs beginning-of-line recognition */ -extern char nmstr[MAXLINE]; -extern int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs, nmval; -extern int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave; -extern int num_backing_up, bol_needed; +//extern char nmstr[MAXLINE]; +//extern int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs, nmval; +//extern int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave; +//extern int num_backing_up, bol_needed; void *allocate_array(int, size_t); void *reallocate_array(void *, int, size_t); @@ -858,7 +858,7 @@ extern void flexfatal(const char *); do{ \ fprintf (stderr,\ _("%s: fatal internal error at %s:%d (%s): %s\n"),\ - program_name, __FILE__, (int)__LINE__,\ + gv->program_name, __FILE__, (int)__LINE__,\ __func__,msg);\ FLEX_EXIT(1);\ }while(0) @@ -1094,17 +1094,17 @@ extern struct Buf *buf_strappend(struct Buf *, const char *str); extern struct Buf *buf_strnappend(struct Buf *, const char *str, int nchars); extern struct Buf *buf_prints(struct Buf *buf, const char *fmt, const char* s); -extern struct Buf userdef_buf; /* a string buffer for #define's generated by user-options on cmd line. */ -extern struct Buf top_buf; /* contains %top code. String buffer. */ +//extern struct Buf userdef_buf; /* a string buffer for #define's generated by user-options on cmd line. */ +//extern struct Buf top_buf; /* contains %top code. String buffer. */ /* For blocking out code from the header file. */ #define OUT_BEGIN_CODE() outn("m4_ifdef( [[M4_YY_IN_HEADER]],,[[m4_dnl") #define OUT_END_CODE() outn("]])") /* For setjmp/longjmp (instead of calling exit(2)). Linkage in main.c */ -extern jmp_buf flex_main_jmp_buf; +//extern jmp_buf flex_main_jmp_buf; -#define FLEX_EXIT(status) longjmp(flex_main_jmp_buf,(status)+1) +#define FLEX_EXIT(status) longjmp(gv->flex_main_jmp_buf,(status)+1) /* Removes all \n and \r chars from tail of str. returns str. */ extern char *chomp (char *str); @@ -1150,7 +1150,7 @@ struct filter { }; /* output filter chain */ -extern struct filter * output_chain; +//extern struct filter * output_chain; extern struct filter *filter_create_ext (struct filter * chain, const char *cmd, ...); struct filter *filter_create_int(struct filter *chain, int (*filter_func) (struct filter *), @@ -1165,7 +1165,7 @@ extern int filter_fix_linedirs(struct filter *chain); * From "regex.c" */ -extern regex_t regex_linedir; +//extern regex_t regex_linedir; bool flex_init_regex(const char *); void flex_regcomp(regex_t *preg, const char *regex, int cflags); char *regmatch_dup (regmatch_t * m, const char *src); @@ -1176,12 +1176,12 @@ bool regmatch_empty (regmatch_t * m); /* From "scanflags.h" */ typedef unsigned int scanflags_t; -extern scanflags_t* _sf_stk; -extern size_t _sf_top_ix, _sf_max; /**< stack of scanner flags. */ +//extern scanflags_t* _sf_stk; +//extern size_t _sf_top_ix, _sf_max; /**< stack of scanner flags. */ #define _SF_CASE_INS ((scanflags_t) 0x0001) #define _SF_DOT_ALL ((scanflags_t) 0x0002) #define _SF_SKIP_WS ((scanflags_t) 0x0004) -#define sf_top() (_sf_stk[_sf_top_ix]) +#define sf_top() (gv->_sf_stk[gv->_sf_top_ix]) #define sf_case_ins() (sf_top() & _SF_CASE_INS) #define sf_dot_all() (sf_top() & _SF_DOT_ALL) #define sf_skip_ws() (sf_top() & _SF_SKIP_WS) @@ -1192,5 +1192,172 @@ extern void sf_init(void); extern void sf_push(void); extern void sf_pop(void); +//From sym.c +/* Variables for symbol tables: + * sctbl - start-condition symbol table + * ndtbl - name-definition symbol table + * ccltab - character class text symbol table + */ + +struct hash_entry { + struct hash_entry *next; + char *name; + char *str_val; + int int_val; +}; + +typedef struct hash_entry **hash_table; + +#define NAME_TABLE_HASH_SIZE 101 +#define START_COND_HASH_SIZE 101 +#define CCL_HASH_SIZE 101 + +#include "tables.h" +typedef struct { + /* these globals are all defined and commented in flexdef.h */ + bool syntaxerror, eofseen; + int yymore_used, reject, real_reject, continued_action, in_rule; + int datapos, dataline, linenum; + FILE *skelfile; + int skel_ind; + char *action_array; + int action_size, defs1_offset, prolog_offset, action_offset, + action_index; + char *infilename; + char *extra_type; + int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE]; + int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp; + int maximum_mns, current_mns, current_max_rules; + int num_rules, num_eof_rules, default_rule, lastnfa; + int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2; + int *accptnum, *assoc_rule, *state_type; + int *rule_type, *rule_linenum; + int current_state_type; + bool variable_trailing_context_rules; + int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP]; + int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE]; + int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, + tecfwd[CSIZE + 1]; + int tecbck[CSIZE + 1]; + int lastsc, *scset, *scbol; + /* scxclu[] and sceof[] are boolean arrays, but allocated as char + * arrays for size. */ + char *scxclu, *sceof; + int current_max_scs; + const char **scname; + int current_max_dfa_size, current_max_xpairs; + int current_max_template_xpairs, current_max_dfas; + int lastdfa, *nxt, *chk, *tnxt; + int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz; + union dfaacc_union { + int *dfaacc_set; + int dfaacc_state; + } *dfaacc; + int *accsiz, *dhash, numas; + int numsnpairs, jambase, jamstate; + int lastccl, *cclmap, *ccllen, *cclng, cclreuse; + int current_maxccls, current_max_ccl_tbl_size; + unsigned char *ccltbl; + char nmstr[MAXLINE]; + int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs, nmval; + int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave; + int num_backing_up, bol_needed; + int end_of_buffer_state; + char **input_files; + int num_input_files; + jmp_buf flex_main_jmp_buf; + /* rule_useful[], rule_has_nl[] and ccl_has_nl[] are boolean arrays, + * but allocated as char arrays for size. */ + char *rule_useful, *rule_has_nl, *ccl_has_nl; + int nlch; + + bool tablesext, tablesverify, gentables; + char *tablesfilename,*tablesname; + struct yytbl_writer tableswr; + size_t footprint; + + struct ctrl_bundle_t ctrl; + struct env_bundle_t env; + + /* Make sure program_name is initialized so we don't crash if writing + * out an error message before getting the program name from argv[0]. + */ + char *program_name; + + struct Buf userdef_buf; /* a string buffer for #define's generated by user-options on cmd line. */ + struct Buf top_buf; /* contains %top code. String buffer. */ + + struct filter * output_chain; + + regex_t regex_linedir; + + scanflags_t* _sf_stk; + size_t _sf_top_ix, _sf_max; /**< stack of scanner flags. */ + + /*static*/ struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE]; + /*static*/ struct hash_entry *sctbl[START_COND_HASH_SIZE]; + /*static*/ struct hash_entry *ccltab[CCL_HASH_SIZE]; + + //from scan.l + /*static*/ int bracelevel, didadef, indented_code; + /*static*/ bool doing_rule_action; + /*static*/ bool option_sense; + + /*static*/ bool doing_codeblock; + int brace_depth, brace_start_line; + char nmdef[MAXLINE]; + + //from dfa.c + /*static*/ int did_stk_init, *stk; + + //from ecs.c + /*static*/ unsigned char cclflags[CSIZE]; /* initialized to all '\0' */ + + //from sym.c + /*static*/ struct hash_entry empty_entry; + + //from yylex.c + /*static*/ int beglin; + + //from misc.c + /*static*/ char rform[20]; + + //from parse.y + int pat, scnum, eps, headcnt, trailcnt, lastchar, i_parse, rulelen; + /*static*/ int currccl; + bool trlcontxt; + /*static*/ bool sc_is_exclusive, cclsorted, varlength, variable_trail_rule; + int *scon_stk; + int scon_stk_ptr; + + /*static*/ int madeany; /* whether we've made the '.' character class */ + /*static*/ int ccldot, cclany; + int previous_continued_action; /* whether the previous rule's action was '|' */ + + //from skeletons.c + /*static*/ char sk_name[256], sk_value[256], *sk_np, *sk_vp; + + //from gen.c + /*static*/ struct packtype_t pack_out; + + //from main.c + /*static*/ int called_before; /* prevent infinite recursion. */ + /*static*/ const char *outfile_template; //[] = "lex.%s.%s"; + /*static*/ const char *backing_name; // = "lex.backup"; + /*static*/ const char *tablesfile_template; //[] = "lex.%s.tables"; + + /*static*/ char outfile_path[MAXLINE]; + /*static*/ int outfile_created; + /*static*/ int _stdout_closed; /* flag to prevent double-fclose() on stdout. */ + const char *escaped_qstart; // = "]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[["; + const char *escaped_qend; // = "]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[["; + + /* For debugging. The max number of filters to apply to skeleton. */ + /*static*/ int preproc_level; + +} FlexState; + +extern FlexState *gv; +void initFlexState(FlexState *fgv); #endif /* not defined FLEXDEF_H */ diff --git a/src/gen.c b/src/gen.c index 3522d875c..143a7682c 100644 --- a/src/gen.c +++ b/src/gen.c @@ -48,15 +48,15 @@ static void genecs(void); struct packtype_t *optimize_pack(size_t sz) { /* FIXME: There's a 32-bit assumption lurking here */ - static struct packtype_t out; + //static struct packtype_t out; if (sz == 0) { - out.name = ctrl.long_align ? "M4_HOOK_INT32" : "M4_HOOK_INT16"; - out.width = ctrl.long_align ? 32 : 16; + gv->pack_out.name = gv->ctrl.long_align ? "M4_HOOK_INT32" : "M4_HOOK_INT16"; + gv->pack_out.width = gv->ctrl.long_align ? 32 : 16; } else { - out.name = (ctrl.long_align || sz >= INT16_MAX) ? "M4_HOOK_INT32" : "M4_HOOK_INT16"; - out.width = (ctrl.long_align || sz >= INT16_MAX) ? 32 : 16; + gv->pack_out.name = (gv->ctrl.long_align || sz >= INT16_MAX) ? "M4_HOOK_INT32" : "M4_HOOK_INT16"; + gv->pack_out.width = (gv->ctrl.long_align || sz >= INT16_MAX) ? 32 : 16; } - return &out; + return &gv->pack_out; } /* Almost everything is done in terms of arrays starting at 1, so provide @@ -77,12 +77,12 @@ static struct yytbl_data *mkeoltbl (void) tbl = calloc(1, sizeof (struct yytbl_data)); yytbl_data_init (tbl, YYTD_ID_RULE_CAN_MATCH_EOL); tbl->td_flags = YYTD_DATA8; - tbl->td_lolen = (flex_uint32_t) (num_rules + 1); + tbl->td_lolen = (flex_uint32_t) (gv->num_rules + 1); tbl->td_data = tdata = calloc(tbl->td_lolen, sizeof (flex_int8_t)); - for (i = 1; i <= num_rules; i++) - tdata[i] = rule_has_nl[i] ? 1 : 0; + for (i = 1; i <= gv->num_rules; i++) + tdata[i] = gv->rule_has_nl[i] ? 1 : 0; return tbl; } @@ -91,22 +91,22 @@ static struct yytbl_data *mkeoltbl (void) static void geneoltbl (void) { int i; - struct packtype_t *ptype = optimize_pack(num_rules); + struct packtype_t *ptype = optimize_pack(gv->num_rules); outn ("m4_ifdef( [[M4_MODE_YYLINENO]],[["); out_str ("m4_define([[M4_HOOK_EOLTABLE_TYPE]], [[%s]])\n", ptype->name); - out_dec ("m4_define([[M4_HOOK_EOLTABLE_SIZE]], [[%d]])", num_rules + 1); + out_dec ("m4_define([[M4_HOOK_EOLTABLE_SIZE]], [[%d]])", gv->num_rules + 1); outn ("m4_define([[M4_HOOK_EOLTABLE_BODY]], [[m4_dnl"); - if (gentables) { - for (i = 1; i <= num_rules; i++) { - out_dec ("%d, ", rule_has_nl[i] ? 1 : 0); + if (gv->gentables) { + for (i = 1; i <= gv->num_rules; i++) { + out_dec ("%d, ", gv->rule_has_nl[i] ? 1 : 0); /* format nicely, 20 numbers per line. */ if ((i % 20) == 19) out ("\n "); } } - footprint += num_rules * ptype->width; + gv->footprint += gv->num_rules * ptype->width; outn ("]])"); outn ("]])"); } @@ -124,16 +124,16 @@ static struct yytbl_data *mkctbl (void) int i; struct yytbl_data *tbl = 0; flex_int32_t *tdata = 0, curr = 0; - int end_of_buffer_action = num_rules + 1; + int end_of_buffer_action = gv->num_rules + 1; - struct packtype_t *ptype = optimize_pack(tblend + 2 + 1); + struct packtype_t *ptype = optimize_pack(gv->tblend + 2 + 1); out_str ("m4_define([[M4_HOOK_MKCTBL_TYPE]], [[%s]])", ptype->name); tbl = calloc(1, sizeof (struct yytbl_data)); yytbl_data_init (tbl, YYTD_ID_TRANSITION); tbl->td_flags = YYTD_DATA32 | YYTD_STRUCT; tbl->td_hilen = 0; - tbl->td_lolen = (flex_uint32_t) (tblend + 2 + 1); /* number of structs */ + tbl->td_lolen = (flex_uint32_t) (gv->tblend + 2 + 1); /* number of structs */ tbl->td_data = tdata = calloc(tbl->td_lolen * 2, sizeof (flex_int32_t)); @@ -156,60 +156,60 @@ static struct yytbl_data *mkctbl (void) * there's room for jam entries for other characters. */ - while (tblend + 2 >= current_max_xpairs) + while (gv->tblend + 2 >= gv->current_max_xpairs) expand_nxt_chk (); - while (lastdfa + 1 >= current_max_dfas) + while (gv->lastdfa + 1 >= gv->current_max_dfas) increase_max_dfas (); - base[lastdfa + 1] = tblend + 2; - nxt[tblend + 1] = end_of_buffer_action; - chk[tblend + 1] = numecs + 1; - chk[tblend + 2] = 1; /* anything but EOB */ + gv->base[gv->lastdfa + 1] = gv->tblend + 2; + gv->nxt[gv->tblend + 1] = end_of_buffer_action; + gv->chk[gv->tblend + 1] = gv->numecs + 1; + gv->chk[gv->tblend + 2] = 1; /* anything but EOB */ /* So that "make test" won't show arb. differences. */ - nxt[tblend + 2] = 0; + gv->nxt[gv->tblend + 2] = 0; /* Make sure every state has an end-of-buffer transition and an * action #. */ - for (i = 0; i <= lastdfa; ++i) { - int anum = dfaacc[i].dfaacc_state; - int offset = base[i]; + for (i = 0; i <= gv->lastdfa; ++i) { + int anum = gv->dfaacc[i].dfaacc_state; + int offset = gv->base[i]; - chk[offset] = EOB_POSITION; - chk[offset - 1] = ACTION_POSITION; - nxt[offset - 1] = anum; /* action number */ + gv->chk[offset] = EOB_POSITION; + gv->chk[offset - 1] = ACTION_POSITION; + gv->nxt[offset - 1] = anum; /* action number */ } - for (i = 0; i <= tblend; ++i) { - if (chk[i] == EOB_POSITION) { + for (i = 0; i <= gv->tblend; ++i) { + if (gv->chk[i] == EOB_POSITION) { tdata[curr++] = 0; - tdata[curr++] = base[lastdfa + 1] - i; + tdata[curr++] = gv->base[gv->lastdfa + 1] - i; } - else if (chk[i] == ACTION_POSITION) { + else if (gv->chk[i] == ACTION_POSITION) { tdata[curr++] = 0; - tdata[curr++] = nxt[i]; + tdata[curr++] = gv->nxt[i]; } - else if (chk[i] > numecs || chk[i] == 0) { + else if (gv->chk[i] > gv->numecs || gv->chk[i] == 0) { tdata[curr++] = 0; tdata[curr++] = 0; } else { /* verify, transition */ - tdata[curr++] = chk[i]; - tdata[curr++] = base[nxt[i]] - (i - chk[i]); + tdata[curr++] = gv->chk[i]; + tdata[curr++] = gv->base[gv->nxt[i]] - (i - gv->chk[i]); } } /* Here's the final, end-of-buffer state. */ - tdata[curr++] = chk[tblend + 1]; - tdata[curr++] = nxt[tblend + 1]; + tdata[curr++] = gv->chk[gv->tblend + 1]; + tdata[curr++] = gv->nxt[gv->tblend + 1]; - tdata[curr++] = chk[tblend + 2]; - tdata[curr++] = nxt[tblend + 2]; + tdata[curr++] = gv->chk[gv->tblend + 2]; + tdata[curr++] = gv->nxt[gv->tblend + 2]; return tbl; } @@ -228,13 +228,13 @@ static struct yytbl_data *mkssltbl (void) yytbl_data_init (tbl, YYTD_ID_START_STATE_LIST); tbl->td_flags = YYTD_DATA32 | YYTD_PTRANS; tbl->td_hilen = 0; - tbl->td_lolen = (flex_uint32_t) (lastsc * 2 + 1); + tbl->td_lolen = (flex_uint32_t) (gv->lastsc * 2 + 1); tbl->td_data = tdata = calloc(tbl->td_lolen, sizeof (flex_int32_t)); - for (i = 0; i <= lastsc * 2; ++i) - tdata[i] = base[i]; + for (i = 0; i <= gv->lastsc * 2; ++i) + tdata[i] = gv->base[i]; return tbl; } @@ -246,10 +246,10 @@ static struct yytbl_data *mkssltbl (void) static void genctbl(void) { int i; - int end_of_buffer_action = num_rules + 1; + int end_of_buffer_action = gv->num_rules + 1; /* Table of verify for transition and offset to next state. */ - out_dec ("m4_define([[M4_HOOK_TRANSTABLE_SIZE]], [[%d]])", tblend + 2 + 1); + out_dec ("m4_define([[M4_HOOK_TRANSTABLE_SIZE]], [[%d]])", gv->tblend + 2 + 1); outn ("m4_define([[M4_HOOK_TRANSTABLE_BODY]], [[m4_dnl"); /* We want the transition to be represented as the offset to the @@ -270,68 +270,68 @@ static void genctbl(void) * there's room for jam entries for other characters. */ - while (tblend + 2 >= current_max_xpairs) + while (gv->tblend + 2 >= gv->current_max_xpairs) expand_nxt_chk (); - while (lastdfa + 1 >= current_max_dfas) + while (gv->lastdfa + 1 >= gv->current_max_dfas) increase_max_dfas (); - base[lastdfa + 1] = tblend + 2; - nxt[tblend + 1] = end_of_buffer_action; - chk[tblend + 1] = numecs + 1; - chk[tblend + 2] = 1; /* anything but EOB */ + gv->base[gv->lastdfa + 1] = gv->tblend + 2; + gv->nxt[gv->tblend + 1] = end_of_buffer_action; + gv->chk[gv->tblend + 1] = gv->numecs + 1; + gv->chk[gv->tblend + 2] = 1; /* anything but EOB */ /* So that "make test" won't show arb. differences. */ - nxt[tblend + 2] = 0; + gv->nxt[gv->tblend + 2] = 0; /* Make sure every state has an end-of-buffer transition and an * action #. */ - for (i = 0; i <= lastdfa; ++i) { - int anum = dfaacc[i].dfaacc_state; - int offset = base[i]; + for (i = 0; i <= gv->lastdfa; ++i) { + int anum = gv->dfaacc[i].dfaacc_state; + int offset = gv->base[i]; - chk[offset] = EOB_POSITION; - chk[offset - 1] = ACTION_POSITION; - nxt[offset - 1] = anum; /* action number */ + gv->chk[offset] = EOB_POSITION; + gv->chk[offset - 1] = ACTION_POSITION; + gv->nxt[offset - 1] = anum; /* action number */ } - for (i = 0; i <= tblend; ++i) { - if (chk[i] == EOB_POSITION) - transition_struct_out (0, base[lastdfa + 1] - i); + for (i = 0; i <= gv->tblend; ++i) { + if (gv->chk[i] == EOB_POSITION) + transition_struct_out (0, gv->base[gv->lastdfa + 1] - i); - else if (chk[i] == ACTION_POSITION) - transition_struct_out (0, nxt[i]); + else if (gv->chk[i] == ACTION_POSITION) + transition_struct_out (0, gv->nxt[i]); - else if (chk[i] > numecs || chk[i] == 0) + else if (gv->chk[i] > gv->numecs || gv->chk[i] == 0) transition_struct_out (0, 0); /* unused slot */ else /* verify, transition */ - transition_struct_out (chk[i], - base[nxt[i]] - (i - - chk[i])); + transition_struct_out (gv->chk[i], + gv->base[gv->nxt[i]] - (i - + gv->chk[i])); } /* Here's the final, end-of-buffer state. */ - transition_struct_out (chk[tblend + 1], nxt[tblend + 1]); - transition_struct_out (chk[tblend + 2], nxt[tblend + 2]); + transition_struct_out (gv->chk[gv->tblend + 1], gv->nxt[gv->tblend + 1]); + transition_struct_out (gv->chk[gv->tblend + 2], gv->nxt[gv->tblend + 2]); outn ("]])"); - footprint += sizeof(struct yy_trans_info) * (tblend + 2 + 1); + gv->footprint += sizeof(struct yy_trans_info) * (gv->tblend + 2 + 1); - out_dec ("m4_define([[M4_HOOK_STARTTABLE_SIZE]], [[%d]])", lastsc * 2 + 1); - if (gentables) { + out_dec ("m4_define([[M4_HOOK_STARTTABLE_SIZE]], [[%d]])", gv->lastsc * 2 + 1); + if (gv->gentables) { outn ("m4_define([[M4_HOOK_STARTTABLE_BODY]], [[m4_dnl"); - for (i = 0; i <= lastsc * 2; ++i) - out_dec ("M4_HOOK_STATE_ENTRY_FORMAT(%d)", base[i]); + for (i = 0; i <= gv->lastsc * 2; ++i) + out_dec ("M4_HOOK_STATE_ENTRY_FORMAT(%d)", gv->base[i]); dataend (NULL); outn("]])"); - footprint += sizeof(struct yy_trans_info *) * (lastsc * 2 + 1); + gv->footprint += sizeof(struct yy_trans_info *) * (gv->lastsc * 2 + 1); } - if (ctrl.useecs) + if (gv->ctrl.useecs) genecs (); } @@ -348,14 +348,14 @@ static struct yytbl_data *mkecstbl (void) yytbl_data_init (tbl, YYTD_ID_EC); tbl->td_flags |= YYTD_DATA32; tbl->td_hilen = 0; - tbl->td_lolen = (flex_uint32_t) ctrl.csize; + tbl->td_lolen = (flex_uint32_t) gv->ctrl.csize; tbl->td_data = tdata = calloc(tbl->td_lolen, sizeof (flex_int32_t)); - for (i = 1; i < ctrl.csize; ++i) { - ecgroup[i] = ABS (ecgroup[i]); - tdata[i] = ecgroup[i]; + for (i = 1; i < gv->ctrl.csize; ++i) { + gv->ecgroup[i] = ABS (gv->ecgroup[i]); + tdata[i] = gv->ecgroup[i]; } return tbl; @@ -368,28 +368,28 @@ static void genecs(void) int ch, row; int numrows; - out_dec ("m4_define([[M4_HOOK_ECSTABLE_SIZE]], [[%d]])", ctrl.csize); + out_dec ("m4_define([[M4_HOOK_ECSTABLE_SIZE]], [[%d]])", gv->ctrl.csize); outn ("m4_define([[M4_HOOK_ECSTABLE_BODY]], [[m4_dnl"); - for (ch = 1; ch < ctrl.csize; ++ch) { - ecgroup[ch] = ABS (ecgroup[ch]); - mkdata (ecgroup[ch]); + for (ch = 1; ch < gv->ctrl.csize; ++ch) { + gv->ecgroup[ch] = ABS (gv->ecgroup[ch]); + mkdata (gv->ecgroup[ch]); } dataend (NULL); outn("]])"); - footprint += sizeof(YY_CHAR) * ctrl.csize; + gv->footprint += sizeof(YY_CHAR) * gv->ctrl.csize; - if (env.trace) { + if (gv->env.trace) { fputs (_("\n\nEquivalence Classes:\n\n"), stderr); /* Print in 8 columns */ - numrows = ctrl.csize / 8; + numrows = gv->ctrl.csize / 8; for (row = 0; row < numrows; ++row) { - for (ch = row; ch < ctrl.csize; ch += numrows) { + for (ch = row; ch < gv->ctrl.csize; ch += numrows) { fprintf (stderr, "%4s = %-2d", - readable_form (ch), ecgroup[ch]); + readable_form (ch), gv->ecgroup[ch]); putc (' ', stderr); } @@ -406,7 +406,7 @@ static void genecs(void) static struct yytbl_data *mkftbl(void) { int i; - int end_of_buffer_action = num_rules + 1; + int end_of_buffer_action = gv->num_rules + 1; struct yytbl_data *tbl; flex_int32_t *tdata = 0; @@ -414,19 +414,19 @@ static struct yytbl_data *mkftbl(void) yytbl_data_init (tbl, YYTD_ID_ACCEPT); tbl->td_flags |= YYTD_DATA32; tbl->td_hilen = 0; /* it's a one-dimensional array */ - tbl->td_lolen = (flex_uint32_t) (lastdfa + 1); + tbl->td_lolen = (flex_uint32_t) (gv->lastdfa + 1); tbl->td_data = tdata = calloc(tbl->td_lolen, sizeof (flex_int32_t)); - dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action; + gv->dfaacc[gv->end_of_buffer_state].dfaacc_state = end_of_buffer_action; - for (i = 1; i <= lastdfa; ++i) { - int anum = dfaacc[i].dfaacc_state; + for (i = 1; i <= gv->lastdfa; ++i) { + int anum = gv->dfaacc[i].dfaacc_state; tdata[i] = anum; - if (env.trace && anum) + if (gv->env.trace && anum) fprintf (stderr, _("state # %d accepts: [%d]\n"), i, anum); } @@ -440,31 +440,31 @@ static struct yytbl_data *mkftbl(void) static void genftbl(void) { int i; - int end_of_buffer_action = num_rules + 1; - struct packtype_t *ptype = optimize_pack(num_rules + 1); + int end_of_buffer_action = gv->num_rules + 1; + struct packtype_t *ptype = optimize_pack(gv->num_rules + 1); - dfaacc[end_of_buffer_state].dfaacc_state = end_of_buffer_action; + gv->dfaacc[gv->end_of_buffer_state].dfaacc_state = end_of_buffer_action; outn ("m4_define([[M4_HOOK_NEED_ACCEPT]], 1)"); out_str ("m4_define([[M4_HOOK_ACCEPT_TYPE]], [[%s]])", ptype->name); - out_dec ("m4_define([[M4_HOOK_ACCEPT_SIZE]], [[%d]])", lastdfa + 1); + out_dec ("m4_define([[M4_HOOK_ACCEPT_SIZE]], [[%d]])", gv->lastdfa + 1); outn ("m4_define([[M4_HOOK_ACCEPT_BODY]], [[m4_dnl"); - for (i = 1; i <= lastdfa; ++i) { - int anum = dfaacc[i].dfaacc_state; + for (i = 1; i <= gv->lastdfa; ++i) { + int anum = gv->dfaacc[i].dfaacc_state; mkdata (anum); - if (env.trace && anum) + if (gv->env.trace && anum) fprintf (stderr, _("state # %d accepts: [%d]\n"), i, anum); } dataend (NULL); outn("]])"); - footprint += (lastdfa + 1) * ptype->width; + gv->footprint += (gv->lastdfa + 1) * ptype->width; - if (ctrl.useecs) + if (gv->ctrl.useecs) genecs (); /* Don't have to dump the actual full table entries - they were @@ -477,7 +477,7 @@ static void genftbl(void) static void gentabs(void) { int sz, i, j, k, *accset, nacc, *acc_array, total_states; - int end_of_buffer_action = num_rules + 1; + int end_of_buffer_action = gv->num_rules + 1; struct yytbl_data *yyacc_tbl = 0, *yymeta_tbl = 0, *yybase_tbl = 0, *yydef_tbl = 0, *yynxt_tbl = 0, *yychk_tbl = 0, *yyacclist_tbl=0; flex_int32_t *yyacc_data = 0, *yybase_data = 0, *yydef_data = 0, @@ -485,17 +485,17 @@ static void gentabs(void) flex_int32_t yybase_curr = 0, yyacclist_curr=0,yyacc_curr=0; struct packtype_t *ptype; - acc_array = allocate_integer_array (current_max_dfas); - nummt = 0; + acc_array = allocate_integer_array (gv->current_max_dfas); + gv->nummt = 0; /* The compressed table format jams by entering the "jam state", * losing information about the previous state in the process. * In order to recover the previous state, we effectively need * to keep backing-up information. */ - ++num_backing_up; + ++gv->num_backing_up; - if (reject) { + if (gv->reject) { /* Write out accepting list and pointer list. * First we generate the "yy_acclist" array. In the process, @@ -507,11 +507,11 @@ static void gentabs(void) /* Set up accepting structures for the End Of Buffer state. */ EOB_accepting_list[0] = 0; EOB_accepting_list[1] = end_of_buffer_action; - accsiz[end_of_buffer_state] = 1; - dfaacc[end_of_buffer_state].dfaacc_set = + gv->accsiz[gv->end_of_buffer_state] = 1; + gv->dfaacc[gv->end_of_buffer_state].dfaacc_set = EOB_accepting_list; - sz = MAX (numas, 1) + 1; + sz = MAX (gv->numas, 1) + 1; ptype = optimize_pack(sz); out_str ("m4_define([[M4_HOOK_ACCLIST_TYPE]], [[%s]])", ptype->name); out_dec ("m4_define([[M4_HOOK_ACCLIST_SIZE]], [[%d]])", sz); @@ -519,21 +519,21 @@ static void gentabs(void) yyacclist_tbl = calloc(1,sizeof(struct yytbl_data)); yytbl_data_init (yyacclist_tbl, YYTD_ID_ACCLIST); - yyacclist_tbl->td_lolen = (flex_uint32_t) (MAX(numas,1) + 1); + yyacclist_tbl->td_lolen = (flex_uint32_t) (MAX(gv->numas,1) + 1); yyacclist_tbl->td_data = yyacclist_data = calloc(yyacclist_tbl->td_lolen, sizeof (flex_int32_t)); yyacclist_curr = 1; j = 1; /* index into "yy_acclist" array */ - for (i = 1; i <= lastdfa; ++i) { + for (i = 1; i <= gv->lastdfa; ++i) { acc_array[i] = j; - if (accsiz[i] != 0) { - accset = dfaacc[i].dfaacc_set; - nacc = accsiz[i]; + if (gv->accsiz[i] != 0) { + accset = gv->dfaacc[i].dfaacc_set; + nacc = gv->accsiz[i]; - if (env.trace) + if (gv->env.trace) fprintf (stderr, _("state # %d accepts: "), i); @@ -543,12 +543,12 @@ static void gentabs(void) ++j; - if (variable_trailing_context_rules + if (gv->variable_trailing_context_rules && !(accnum & YY_TRAILING_HEAD_MASK) && accnum > 0 - && accnum <= num_rules - && rule_type[accnum] == + && accnum <= gv->num_rules + && gv->rule_type[accnum] == RULE_VARIABLE) { /* Special hack to flag * accepting number as part @@ -560,7 +560,7 @@ static void gentabs(void) mkdata (accnum); yyacclist_data[yyacclist_curr++] = accnum; - if (env.trace) { + if (gv->env.trace) { fprintf (stderr, "[%d]", accset[k]); @@ -580,10 +580,10 @@ static void gentabs(void) dataend (NULL); outn("]])"); - footprint += sz * ptype->width; - if (tablesext) { + gv->footprint += sz * ptype->width; + if (gv->tablesext) { yytbl_data_compress (yyacclist_tbl); - if (yytbl_data_fwrite (&tableswr, yyacclist_tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, yyacclist_tbl) < 0) flexerror (_("Could not write yyacclist_tbl")); yytbl_data_destroy (yyacclist_tbl); yyacclist_tbl = NULL; @@ -591,11 +591,11 @@ static void gentabs(void) } else { - dfaacc[end_of_buffer_state].dfaacc_state = + gv->dfaacc[gv->end_of_buffer_state].dfaacc_state = end_of_buffer_action; - for (i = 1; i <= lastdfa; ++i) - acc_array[i] = dfaacc[i].dfaacc_state; + for (i = 1; i <= gv->lastdfa; ++i) + acc_array[i] = gv->dfaacc[i].dfaacc_state; /* add accepting number for jam state */ acc_array[i] = 0; @@ -611,9 +611,9 @@ static void gentabs(void) /* "lastdfa + 2" is the size of "yy_accept"; includes room for C arrays * beginning at 0 and for "jam" state. */ - sz = lastdfa + 2; + sz = gv->lastdfa + 2; - if (reject) + if (gv->reject) /* We put a "cap" on the table associating lists of accepting * numbers with state numbers. This is needed because we tell * where the end of an accepting list is by looking at where @@ -635,11 +635,11 @@ static void gentabs(void) calloc(yyacc_tbl->td_lolen, sizeof (flex_int32_t)); yyacc_curr=1; - for (i = 1; i <= lastdfa; ++i) { + for (i = 1; i <= gv->lastdfa; ++i) { mkdata (acc_array[i]); yyacc_data[yyacc_curr++] = acc_array[i]; - if (!reject && env.trace && acc_array[i]) + if (!gv->reject && gv->env.trace && acc_array[i]) fprintf (stderr, _("state # %d accepts: [%d]\n"), i, acc_array[i]); } @@ -648,7 +648,7 @@ static void gentabs(void) mkdata (acc_array[i]); yyacc_data[yyacc_curr++] = acc_array[i]; - if (reject) { + if (gv->reject) { /* Add "cap" for the list. */ mkdata (acc_array[i]); yyacc_data[yyacc_curr++] = acc_array[i]; @@ -656,33 +656,33 @@ static void gentabs(void) dataend (NULL); outn ("]])"); - footprint += sz * ptype->width; + gv->footprint += sz * ptype->width; - if (tablesext) { + if (gv->tablesext) { yytbl_data_compress (yyacc_tbl); - if (yytbl_data_fwrite (&tableswr, yyacc_tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, yyacc_tbl) < 0) flexerror (_("Could not write yyacc_tbl")); } yytbl_data_destroy (yyacc_tbl); yyacc_tbl = NULL; /* End generating yy_accept */ - if (ctrl.useecs) { + if (gv->ctrl.useecs) { genecs (); - if (tablesext) { + if (gv->tablesext) { struct yytbl_data *tbl; tbl = mkecstbl (); yytbl_data_compress (tbl); - if (yytbl_data_fwrite (&tableswr, tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, tbl) < 0) flexerror (_("Could not write ecstbl")); yytbl_data_destroy (tbl); tbl = 0; } } - if (ctrl.usemecs) { + if (gv->ctrl.usemecs) { /* Begin generating yy_meta */ /* Write out meta-equivalence classes (used to index * templates with). @@ -690,32 +690,32 @@ static void gentabs(void) flex_int32_t *yymecs_data = 0; yymeta_tbl = calloc(1, sizeof (struct yytbl_data)); yytbl_data_init (yymeta_tbl, YYTD_ID_META); - yymeta_tbl->td_lolen = (flex_uint32_t) (numecs + 1); + yymeta_tbl->td_lolen = (flex_uint32_t) (gv->numecs + 1); yymeta_tbl->td_data = yymecs_data = calloc(yymeta_tbl->td_lolen, sizeof (flex_int32_t)); - if (env.trace) + if (gv->env.trace) fputs (_("\n\nMeta-Equivalence Classes:\n"), stderr); - out_dec ("m4_define([[M4_HOOK_MECSTABLE_SIZE]], [[%d]])", numecs+1); + out_dec ("m4_define([[M4_HOOK_MECSTABLE_SIZE]], [[%d]])", gv->numecs+1); outn ("m4_define([[M4_HOOK_MECSTABLE_BODY]], [[m4_dnl"); - for (i = 1; i <= numecs; ++i) { - if (env.trace) + for (i = 1; i <= gv->numecs; ++i) { + if (gv->env.trace) fprintf (stderr, "%d = %d\n", - i, ABS (tecbck[i])); + i, ABS (gv->tecbck[i])); - mkdata (ABS (tecbck[i])); - yymecs_data[i] = ABS (tecbck[i]); + mkdata (ABS (gv->tecbck[i])); + yymecs_data[i] = ABS (gv->tecbck[i]); } dataend (NULL); outn ("]])"); - footprint += sizeof(YY_CHAR) * (numecs + 1); - if (tablesext) { + gv->footprint += sizeof(YY_CHAR) * (gv->numecs + 1); + if (gv->tablesext) { yytbl_data_compress (yymeta_tbl); - if (yytbl_data_fwrite (&tableswr, yymeta_tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, yymeta_tbl) < 0) flexerror (_("Could not write yymeta_tbl")); } yytbl_data_destroy (yymeta_tbl); @@ -723,7 +723,7 @@ static void gentabs(void) /* End generating yy_meta */ } - total_states = lastdfa + numtemps; + total_states = gv->lastdfa + gv->numtemps; /* Begin generating yy_base */ sz = total_states + 1; @@ -740,42 +740,42 @@ static void gentabs(void) sizeof (flex_int32_t)); yybase_curr = 1; - for (i = 1; i <= lastdfa; ++i) { - int d = def[i]; + for (i = 1; i <= gv->lastdfa; ++i) { + int d = gv->def[i]; - if (base[i] == JAMSTATE) - base[i] = jambase; + if (gv->base[i] == JAMSTATE) + gv->base[i] = gv->jambase; if (d == JAMSTATE) - def[i] = jamstate; + gv->def[i] = gv->jamstate; else if (d < 0) { /* Template reference. */ - ++tmpuses; - def[i] = lastdfa - d + 1; + ++gv->tmpuses; + gv->def[i] = gv->lastdfa - d + 1; } - mkdata (base[i]); - yybase_data[yybase_curr++] = base[i]; + mkdata (gv->base[i]); + yybase_data[yybase_curr++] = gv->base[i]; } /* Generate jam state's base index. */ - mkdata (base[i]); - yybase_data[yybase_curr++] = base[i]; + mkdata (gv->base[i]); + yybase_data[yybase_curr++] = gv->base[i]; for (++i /* skip jam state */ ; i <= total_states; ++i) { - mkdata (base[i]); - yybase_data[yybase_curr++] = base[i]; - def[i] = jamstate; + mkdata (gv->base[i]); + yybase_data[yybase_curr++] = gv->base[i]; + gv->def[i] = gv->jamstate; } dataend (NULL); outn ("]])"); - footprint += sz * ptype->width; + gv->footprint += sz * ptype->width; - if (tablesext) { + if (gv->tablesext) { yytbl_data_compress (yybase_tbl); - if (yytbl_data_fwrite (&tableswr, yybase_tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, yybase_tbl) < 0) flexerror (_("Could not write yybase_tbl")); } yytbl_data_destroy (yybase_tbl); @@ -796,17 +796,17 @@ static void gentabs(void) calloc(yydef_tbl->td_lolen, sizeof (flex_int32_t)); for (i = 1; i <= total_states; ++i) { - mkdata (def[i]); - yydef_data[i] = def[i]; + mkdata (gv->def[i]); + yydef_data[i] = gv->def[i]; } dataend (NULL); outn ("]])"); - footprint += (total_states + 1) * ptype->width; + gv->footprint += (total_states + 1) * ptype->width; - if (tablesext) { + if (gv->tablesext) { yytbl_data_compress (yydef_tbl); - if (yytbl_data_fwrite (&tableswr, yydef_tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, yydef_tbl) < 0) flexerror (_("Could not write yydef_tbl")); } yytbl_data_destroy (yydef_tbl); @@ -814,38 +814,38 @@ static void gentabs(void) /* End generating yy_def */ - ptype = optimize_pack(tblend + 1); + ptype = optimize_pack(gv->tblend + 1); /* Note: Used when !ctrl.fulltbl && !ctrl.fullspd). * (Alternately defined when ctrl.fullspd) */ out_str ("m4_define([[M4_HOOK_YYNXT_TYPE]], [[%s]])", ptype->name); - out_dec ("m4_define([[M4_HOOK_YYNXT_SIZE]], [[%d]])", tblend + 1); + out_dec ("m4_define([[M4_HOOK_YYNXT_SIZE]], [[%d]])", gv->tblend + 1); outn ("m4_define([[M4_HOOK_YYNXT_BODY]], [[m4_dnl"); yynxt_tbl = calloc (1, sizeof (struct yytbl_data)); yytbl_data_init (yynxt_tbl, YYTD_ID_NXT); - yynxt_tbl->td_lolen = (flex_uint32_t) (tblend + 1); + yynxt_tbl->td_lolen = (flex_uint32_t) (gv->tblend + 1); yynxt_tbl->td_data = yynxt_data = calloc (yynxt_tbl->td_lolen, sizeof (flex_int32_t)); - for (i = 1; i <= tblend; ++i) { + for (i = 1; i <= gv->tblend; ++i) { /* Note, the order of the following test is important. * If chk[i] is 0, then nxt[i] is undefined. */ - if (chk[i] == 0 || nxt[i] == 0) - nxt[i] = jamstate; /* new state is the JAM state */ + if (gv->chk[i] == 0 || gv->nxt[i] == 0) + gv->nxt[i] = gv->jamstate; /* new state is the JAM state */ - mkdata (nxt[i]); - yynxt_data[i] = nxt[i]; + mkdata (gv->nxt[i]); + yynxt_data[i] = gv->nxt[i]; } dataend (NULL); outn("]])"); - footprint += ptype->width * (tblend + 1); + gv->footprint += ptype->width * (gv->tblend + 1); - if (tablesext) { + if (gv->tablesext) { yytbl_data_compress (yynxt_tbl); - if (yytbl_data_fwrite (&tableswr, yynxt_tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, yynxt_tbl) < 0) flexerror (_("Could not write yynxt_tbl")); } yytbl_data_destroy (yynxt_tbl); @@ -853,32 +853,32 @@ static void gentabs(void) /* End generating yy_nxt */ /* Begin generating yy_chk */ - ptype = optimize_pack(tblend + 1); + ptype = optimize_pack(gv->tblend + 1); out_str ("m4_define([[M4_HOOK_CHK_TYPE]], [[%s]])", ptype->name); - out_dec ("m4_define([[M4_HOOK_CHK_SIZE]], [[%d]])", tblend + 1); + out_dec ("m4_define([[M4_HOOK_CHK_SIZE]], [[%d]])", gv->tblend + 1); outn ("m4_define([[M4_HOOK_CHK_BODY]], [[m4_dnl"); yychk_tbl = calloc (1, sizeof (struct yytbl_data)); yytbl_data_init (yychk_tbl, YYTD_ID_CHK); - yychk_tbl->td_lolen = (flex_uint32_t) (tblend + 1); + yychk_tbl->td_lolen = (flex_uint32_t) (gv->tblend + 1); yychk_tbl->td_data = yychk_data = calloc(yychk_tbl->td_lolen, sizeof (flex_int32_t)); - for (i = 1; i <= tblend; ++i) { - if (chk[i] == 0) - ++nummt; + for (i = 1; i <= gv->tblend; ++i) { + if (gv->chk[i] == 0) + ++gv->nummt; - mkdata (chk[i]); - yychk_data[i] = chk[i]; + mkdata (gv->chk[i]); + yychk_data[i] = gv->chk[i]; } dataend (NULL); outn ("]])"); - footprint += ptype->width * (tblend + 1); + gv->footprint += ptype->width * (gv->tblend + 1); - if (tablesext) { + if (gv->tablesext) { yytbl_data_compress (yychk_tbl); - if (yytbl_data_fwrite (&tableswr, yychk_tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, yychk_tbl) < 0) flexerror (_("Could not write yychk_tbl")); } yytbl_data_destroy (yychk_tbl); @@ -926,28 +926,28 @@ void make_tables (void) /* This is where we REALLY begin generating the tables. */ - if (ctrl.fullspd) { + if (gv->ctrl.fullspd) { genctbl (); - if (tablesext) { + if (gv->tablesext) { struct yytbl_data *tbl; tbl = mkctbl (); yytbl_data_compress (tbl); - if (yytbl_data_fwrite (&tableswr, tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, tbl) < 0) flexerror (_("Could not write ftbl")); yytbl_data_destroy (tbl); tbl = mkssltbl (); yytbl_data_compress (tbl); - if (yytbl_data_fwrite (&tableswr, tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, tbl) < 0) flexerror (_("Could not write ssltbl")); yytbl_data_destroy (tbl); tbl = 0; - if (ctrl.useecs) { + if (gv->ctrl.useecs) { tbl = mkecstbl (); yytbl_data_compress (tbl); - if (yytbl_data_fwrite (&tableswr, tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, tbl) < 0) flexerror (_ ("Could not write ecstbl")); yytbl_data_destroy (tbl); @@ -955,26 +955,26 @@ void make_tables (void) } } } - else if (ctrl.fulltbl) { + else if (gv->ctrl.fulltbl) { genftbl (); - if (tablesext) { + if (gv->tablesext) { struct yytbl_data *tbl; - /* Alternately defined if !ctrl.ffullspd && !ctrl.fulltbl */ + /* Alternately defined if !gv->ctrl.ffullspd && !gv->ctrl.fulltbl */ struct packtype_t *ptype; tbl = mkftbl (); yytbl_data_compress (tbl); ptype = optimize_pack(tbl->td_lolen); out_str ("m4_define([[M4_HOOK_ACCEPT_TYPE]], [[%s]])", ptype->name); - if (yytbl_data_fwrite (&tableswr, tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, tbl) < 0) flexerror (_("Could not write ftbl")); yytbl_data_destroy (tbl); tbl = 0; - if (ctrl.useecs) { + if (gv->ctrl.useecs) { tbl = mkecstbl (); yytbl_data_compress (tbl); - if (yytbl_data_fwrite (&tableswr, tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, tbl) < 0) flexerror (_ ("Could not write ecstbl")); yytbl_data_destroy (tbl); @@ -986,15 +986,15 @@ void make_tables (void) gentabs (); } - snprintf(buf, sizeof(buf), "footprint: %ld bytes\n", footprint); + snprintf(buf, sizeof(buf), "footprint: %ld bytes\n", gv->footprint); comment(buf); - snprintf(buf, sizeof(buf), "tblend: %d\n", tblend); + snprintf(buf, sizeof(buf), "tblend: %d\n", gv->tblend); comment(buf); - snprintf(buf, sizeof(buf), "numecs: %d\n", numecs); + snprintf(buf, sizeof(buf), "numecs: %d\n", gv->numecs); comment(buf); - snprintf(buf, sizeof(buf), "num_rules: %d\n", num_rules); + snprintf(buf, sizeof(buf), "num_rules: %d\n", gv->num_rules); comment(buf); - snprintf(buf, sizeof(buf), "lastdfa: %d\n", lastdfa); + snprintf(buf, sizeof(buf), "lastdfa: %d\n", gv->lastdfa); comment(buf); outc ('\n'); @@ -1003,73 +1003,73 @@ void make_tables (void) comment("m4 controls begin\n"); - if (num_backing_up > 0) + if (gv->num_backing_up > 0) visible_define ( "M4_MODE_HAS_BACKING_UP"); // These are used for NUL transitions - if ((num_backing_up > 0 && !reject) && (!nultrans || ctrl.fullspd || ctrl.fulltbl)) + if ((gv->num_backing_up > 0 && !gv->reject) && (!gv->nultrans || gv->ctrl.fullspd || gv->ctrl.fulltbl)) visible_define ( "M4_MODE_NEED_YY_CP"); - if ((num_backing_up > 0 && !reject) && (ctrl.fullspd || ctrl.fulltbl)) + if ((gv->num_backing_up > 0 && !gv->reject) && (gv->ctrl.fullspd || gv->ctrl.fulltbl)) visible_define ( "M4_MODE_NULTRANS_WRAP"); comment("m4 controls end\n"); out ("\n"); - if (ctrl.do_yylineno) { + if (gv->ctrl.do_yylineno) { geneoltbl (); - if (tablesext) { + if (gv->tablesext) { struct yytbl_data *tbl; tbl = mkeoltbl (); yytbl_data_compress (tbl); - if (yytbl_data_fwrite (&tableswr, tbl) < 0) + if (yytbl_data_fwrite (&gv->tableswr, tbl) < 0) flexerror (_("Could not write eoltbl")); yytbl_data_destroy (tbl); tbl = 0; } } - if (nultrans) { + if (gv->nultrans) { flex_int32_t *yynultrans_data = 0; /* Begin generating yy_NUL_trans */ - out_str ("m4_define([[M4_HOOK_NULTRANS_TYPE]], [[%s]])", (ctrl.fullspd) ? "struct yy_trans_info*" : "M4_HOOK_INT32"); - out_dec ("m4_define([[M4_HOOK_NULTRANS_SIZE]], [[%d]])", lastdfa + 1); + out_str ("m4_define([[M4_HOOK_NULTRANS_TYPE]], [[%s]])", (gv->ctrl.fullspd) ? "struct yy_trans_info*" : "M4_HOOK_INT32"); + out_dec ("m4_define([[M4_HOOK_NULTRANS_SIZE]], [[%d]])", gv->lastdfa + 1); outn ("m4_define([[M4_HOOK_NULTRANS_BODY]], [[m4_dnl"); yynultrans_tbl = calloc(1, sizeof (struct yytbl_data)); yytbl_data_init (yynultrans_tbl, YYTD_ID_NUL_TRANS); // Performance kludge for C. Gives a small improvement // in table loading time. - if (ctrl.fullspd && ctrl.have_state_entry_format) + if (gv->ctrl.fullspd && gv->ctrl.have_state_entry_format) yynultrans_tbl->td_flags |= YYTD_PTRANS; - yynultrans_tbl->td_lolen = (flex_uint32_t) (lastdfa + 1); + yynultrans_tbl->td_lolen = (flex_uint32_t) (gv->lastdfa + 1); yynultrans_tbl->td_data = yynultrans_data = calloc(yynultrans_tbl->td_lolen, sizeof (flex_int32_t)); - for (i = 1; i <= lastdfa; ++i) { + for (i = 1; i <= gv->lastdfa; ++i) { if ((yynultrans_tbl->td_flags & YYTD_PTRANS) != 0) { // Only works in very C-like languages out_dec (" &yy_transition[%d],\n", - base[i]); - yynultrans_data[i] = base[i]; + gv->base[i]); + yynultrans_data[i] = gv->base[i]; } else { // This will work anywhere - mkdata (nultrans[i]); - yynultrans_data[i] = nultrans[i]; + mkdata (gv->nultrans[i]); + yynultrans_data[i] = gv->nultrans[i]; } } dataend (NULL); outn("]])"); - footprint += (lastdfa + 1) * (ctrl.fullspd ? sizeof(struct yy_trans_info *) : sizeof(int32_t)); - if (tablesext) { + gv->footprint += (gv->lastdfa + 1) * (gv->ctrl.fullspd ? sizeof(struct yy_trans_info *) : sizeof(int32_t)); + if (gv->tablesext) { yytbl_data_compress (yynultrans_tbl); - if (yytbl_data_fwrite (&tableswr, yynultrans_tbl) < + if (yytbl_data_fwrite (&gv->tableswr, yynultrans_tbl) < 0) flexerror (_ ("Could not write yynultrans_tbl")); @@ -1083,17 +1083,17 @@ void make_tables (void) /* End generating yy_NUL_trans */ } - if (ctrl.ddebug) { /* Spit out table mapping rules to line numbers. */ + if (gv->ctrl.ddebug) { /* Spit out table mapping rules to line numbers. */ /* Policy choice: we don't include this space * in the table metering. */ - struct packtype_t *ptype = optimize_pack(num_rules); + struct packtype_t *ptype = optimize_pack(gv->num_rules); out_str ("m4_define([[M4_HOOK_DEBUGTABLE_TYPE]], [[%s]])", ptype->name); - out_dec ("m4_define([[M4_HOOK_DEBUGTABLE_SIZE]], [[%d]])", num_rules); + out_dec ("m4_define([[M4_HOOK_DEBUGTABLE_SIZE]], [[%d]])", gv->num_rules); outn ("m4_define([[M4_HOOK_DEBUGTABLE_BODY]], [[m4_dnl"); - for (i = 1; i < num_rules; ++i) - mkdata (rule_linenum[i]); + for (i = 1; i < gv->num_rules; ++i) + mkdata (gv->rule_linenum[i]); dataend (NULL); outn("]])"); } diff --git a/src/main.c b/src/main.c index 56ca8ae3c..ab2187b4e 100644 --- a/src/main.c +++ b/src/main.c @@ -38,7 +38,7 @@ #include "tables.h" #include "parse.h" -static char flex_version[] = FLEX_VERSION; +static const char flex_version[] = FLEX_VERSION; /* declare functions that have forward references */ @@ -46,88 +46,103 @@ void flexinit(int, char **); void readin(void); void set_up_initial_allocations(void); -/* these globals are all defined and commented in flexdef.h */ -bool syntaxerror, eofseen; -int yymore_used, reject, real_reject, continued_action, in_rule; -int datapos, dataline, linenum; -FILE *skelfile = NULL; -int skel_ind = 0; -char *action_array; -int action_size, defs1_offset, prolog_offset, action_offset, - action_index; -char *infilename = NULL; -char *extra_type = NULL; -int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE]; -int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp; -int maximum_mns, current_mns, current_max_rules; -int num_rules, num_eof_rules, default_rule, lastnfa; -int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2; -int *accptnum, *assoc_rule, *state_type; -int *rule_type, *rule_linenum; -int current_state_type; -bool variable_trailing_context_rules; -int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP]; -int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE]; -int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, - tecfwd[CSIZE + 1]; -int tecbck[CSIZE + 1]; -int lastsc, *scset, *scbol; -/* scxclu[] and sceof[] are boolean arrays, but allocated as char - * arrays for size. */ -char *scxclu, *sceof; -int current_max_scs; -const char **scname; -int current_max_dfa_size, current_max_xpairs; -int current_max_template_xpairs, current_max_dfas; -int lastdfa, *nxt, *chk, *tnxt; -int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz; -union dfaacc_union *dfaacc; -int *accsiz, *dhash, numas; -int numsnpairs, jambase, jamstate; -int lastccl, *cclmap, *ccllen, *cclng, cclreuse; -int current_maxccls, current_max_ccl_tbl_size; -unsigned char *ccltbl; -char nmstr[MAXLINE]; -int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs, nmval; -int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave; -int num_backing_up, bol_needed; -int end_of_buffer_state; -char **input_files; -int num_input_files; -jmp_buf flex_main_jmp_buf; -/* rule_useful[], rule_has_nl[] and ccl_has_nl[] are boolean arrays, - * but allocated as char arrays for size. */ -char *rule_useful, *rule_has_nl, *ccl_has_nl; -int nlch = '\n'; - -bool tablesext, tablesverify, gentables; -char *tablesfilename=0,*tablesname=0; -struct yytbl_writer tableswr; -size_t footprint; - -struct ctrl_bundle_t ctrl; -struct env_bundle_t env; - -/* Make sure program_name is initialized so we don't crash if writing - * out an error message before getting the program name from argv[0]. - */ -char *program_name = "flex"; +///* these globals are all defined and commented in flexdef.h */ +//bool syntaxerror, eofseen; +//int yymore_used, reject, real_reject, continued_action, in_rule; +//int datapos, dataline, linenum; +//FILE *skelfile = NULL; +//int skel_ind = 0; +//char *action_array; +//int action_size, defs1_offset, prolog_offset, action_offset, +// action_index; +//char *infilename = NULL; +//char *extra_type = NULL; +//int onestate[ONE_STACK_SIZE], onesym[ONE_STACK_SIZE]; +//int onenext[ONE_STACK_SIZE], onedef[ONE_STACK_SIZE], onesp; +//int maximum_mns, current_mns, current_max_rules; +//int num_rules, num_eof_rules, default_rule, lastnfa; +//int *firstst, *lastst, *finalst, *transchar, *trans1, *trans2; +//int *accptnum, *assoc_rule, *state_type; +//int *rule_type, *rule_linenum; +//int current_state_type; +//bool variable_trailing_context_rules; +//int numtemps, numprots, protprev[MSP], protnext[MSP], prottbl[MSP]; +//int protcomst[MSP], firstprot, lastprot, protsave[PROT_SAVE_SIZE]; +//int numecs, nextecm[CSIZE + 1], ecgroup[CSIZE + 1], nummecs, +// tecfwd[CSIZE + 1]; +//int tecbck[CSIZE + 1]; +//int lastsc, *scset, *scbol; +///* scxclu[] and sceof[] are boolean arrays, but allocated as char +// * arrays for size. */ +//char *scxclu, *sceof; +//int current_max_scs; +//const char **scname; +//int current_max_dfa_size, current_max_xpairs; +//int current_max_template_xpairs, current_max_dfas; +//int lastdfa, *nxt, *chk, *tnxt; +//int *base, *def, *nultrans, NUL_ec, tblend, firstfree, **dss, *dfasiz; +//union dfaacc_union *dfaacc; +//int *accsiz, *dhash, numas; +//int numsnpairs, jambase, jamstate; +//int lastccl, *cclmap, *ccllen, *cclng, cclreuse; +//int current_maxccls, current_max_ccl_tbl_size; +//unsigned char *ccltbl; +//char nmstr[MAXLINE]; +//int sectnum, nummt, hshcol, dfaeql, numeps, eps2, num_reallocs, nmval; +//int tmpuses, totnst, peakpairs, numuniq, numdup, hshsave; +//int num_backing_up, bol_needed; +//int end_of_buffer_state; +//char **input_files; +//int num_input_files; +//jmp_buf flex_main_jmp_buf; +///* rule_useful[], rule_has_nl[] and ccl_has_nl[] are boolean arrays, +// * but allocated as char arrays for size. */ +//char *rule_useful, *rule_has_nl, *ccl_has_nl; +//int nlch = '\n'; +// +//bool tablesext, tablesverify, gentables; +//char *tablesfilename=0,*tablesname=0; +//struct yytbl_writer tableswr; +//size_t footprint; +// +//struct ctrl_bundle_t ctrl; +//struct env_bundle_t env; +// +///* Make sure program_name is initialized so we don't crash if writing +// * out an error message before getting the program name from argv[0]. +// */ +//char *program_name = "flex"; + +FlexState *gv; +void initFlexState(FlexState *fgv) +{ + memset(fgv, 0, sizeof(*fgv)); + fgv->nlch = '\n'; + fgv->program_name = "flex"; + fgv->escaped_qstart = "]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[["; + fgv->escaped_qend = "]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[["; + fgv->called_before = -1; + fgv->outfile_template = "lex.%s.%s"; + fgv->backing_name = "lex.backup"; + fgv->tablesfile_template = "lex.%s.tables"; + fgv->preproc_level = 1000; +} -static const char outfile_template[] = "lex.%s.%s"; -static const char *backing_name = "lex.backup"; -static const char tablesfile_template[] = "lex.%s.tables"; +//static const char outfile_template[] = "lex.%s.%s"; +//static const char *backing_name = "lex.backup"; +//static const char tablesfile_template[] = "lex.%s.tables"; /* From scan.l */ extern FILE* yyout; -static char outfile_path[MAXLINE]; -static int outfile_created = 0; -static int _stdout_closed = 0; /* flag to prevent double-fclose() on stdout. */ -const char *escaped_qstart = "]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[["; -const char *escaped_qend = "]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[["; +//static char outfile_path[MAXLINE]; +//static int outfile_created = 0; +//static int _stdout_closed = 0; /* flag to prevent double-fclose() on stdout. */ +//const char *escaped_qstart = "]]M4_YY_NOOP[M4_YY_NOOP[M4_YY_NOOP[["; +//const char *escaped_qend = "]]M4_YY_NOOP]M4_YY_NOOP]M4_YY_NOOP[["; /* For debugging. The max number of filters to apply to skeleton. */ -static int preproc_level = 1000; +//static int preproc_level = 1000; int flex_main (int argc, char *argv[]); @@ -135,6 +150,9 @@ int flex_main (int argc, char *argv[]) { int i, exit_status, child_status; int did_eof_rule = false; + FlexState fgv; + initFlexState(&fgv); + gv = &fgv; /* Set a longjmp target. Yes, I know it's a hack, but it gets worse: The * return value of setjmp, if non-zero, is the desired exit code PLUS ONE. @@ -143,9 +161,9 @@ int flex_main (int argc, char *argv[]) * specify a value of 0 to longjmp. FLEX_EXIT(n) should be used instead of * exit(n); */ - exit_status = setjmp (flex_main_jmp_buf); + exit_status = setjmp (gv->flex_main_jmp_buf); if (exit_status){ - if (stdout && !_stdout_closed && !ferror(stdout)){ + if (stdout && !gv->_stdout_closed && !ferror(stdout)){ fflush(stdout); fclose(stdout); } @@ -166,31 +184,31 @@ int flex_main (int argc, char *argv[]) readin (); skelout (true); /* %% [1.0] DFA */ - footprint += ntod (); + gv->footprint += ntod (); - for (i = 1; i <= num_rules; ++i) - if (!rule_useful[i] && i != default_rule) + for (i = 1; i <= gv->num_rules; ++i) + if (!gv->rule_useful[i] && i != gv->default_rule) line_warning (_("rule cannot be matched"), - rule_linenum[i]); + gv->rule_linenum[i]); - if (ctrl.spprdflt && !reject && rule_useful[default_rule]) + if (gv->ctrl.spprdflt && !gv->reject && gv->rule_useful[gv->default_rule]) line_warning (_ ("-s option given but default rule can be matched"), - rule_linenum[default_rule]); + gv->rule_linenum[gv->default_rule]); comment("START of m4 controls\n"); // mode switches for yy_trans_info specification // nultrans - if (nultrans) + if (gv->nultrans) visible_define ( "M4_MODE_NULTRANS"); else { visible_define ( "M4_MODE_NO_NULTRANS"); - if (ctrl.fulltbl) + if (gv->ctrl.fulltbl) visible_define ( "M4_MODE_NULTRANS_FULLTBL"); else visible_define ( "M4_MODE_NO_NULTRANS_FULLTBL"); - if (ctrl.fullspd) + if (gv->ctrl.fullspd) visible_define ( "M4_MODE_NULTRANS_FULLSPD"); else visible_define ( "M4_MODE_NO_NULTRANS_FULLSPD"); @@ -200,15 +218,15 @@ int flex_main (int argc, char *argv[]) out ("\n"); comment("START of Flex-generated definitions\n"); - out_str_dec ("M4_HOOK_CONST_DEFINE_UINT(%s, %d)", "YY_NUM_RULES", num_rules); - out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_END_OF_BUFFER", num_rules + 1); - out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_JAMBASE", jambase); - out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_JAMSTATE", jamstate); - out_str_dec ("M4_HOOK_CONST_DEFINE_BYTE(%s, %d)", "YY_NUL_EC", NUL_ec); + out_str_dec ("M4_HOOK_CONST_DEFINE_UINT(%s, %d)", "YY_NUM_RULES", gv->num_rules); + out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_END_OF_BUFFER", gv->num_rules + 1); + out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_JAMBASE", gv->jambase); + out_str_dec ("M4_HOOK_CONST_DEFINE_STATE(%s, %d)", "YY_JAMSTATE", gv->jamstate); + out_str_dec ("M4_HOOK_CONST_DEFINE_BYTE(%s, %d)", "YY_NUL_EC", gv->NUL_ec); /* Need to define the transet type as a size large * enough to hold the biggest offset. */ - out_str ("M4_HOOK_SET_OFFSET_TYPE(%s)", optimize_pack(tblend + numecs + 1)->name); + out_str ("M4_HOOK_SET_OFFSET_TYPE(%s)", optimize_pack(gv->tblend + gv->numecs + 1)->name); comment("END of Flex-generated definitions\n"); skelout (true); /* %% [2.0] - tables get dumped here */ @@ -218,28 +236,28 @@ int flex_main (int argc, char *argv[]) skelout (true); /* %% [3.0] - mode-dependent static declarations get dumped here */ - out (&action_array[defs1_offset]); + out (&gv->action_array[gv->defs1_offset]); - line_directive_out (stdout, NULL, linenum); + line_directive_out (stdout, NULL, gv->linenum); skelout (true); /* %% [4.0] - various random yylex internals get dumped here */ /* Copy prolog to output file. */ - out (&action_array[prolog_offset]); + out (&gv->action_array[gv->prolog_offset]); - line_directive_out (stdout, NULL, linenum); + line_directive_out (stdout, NULL, gv->linenum); skelout (true); /* %% [5.0] - main loop of matching-engine code gets dumped here */ /* Copy actions to output file. */ - out (&action_array[action_offset]); + out (&gv->action_array[gv->action_offset]); - line_directive_out (stdout, NULL, linenum); + line_directive_out (stdout, NULL, gv->linenum); /* generate cases for any missing EOF rules */ - for (i = 1; i <= lastsc; ++i) - if (!sceof[i]) { - out_str ("M4_HOOK_EOF_STATE_CASE_ARM(%s)", scname[i]); + for (i = 1; i <= gv->lastsc; ++i) + if (!gv->sceof[i]) { + out_str ("M4_HOOK_EOF_STATE_CASE_ARM(%s)", gv->scname[i]); outc('\n'); out ("M4_HOOK_EOF_STATE_CASE_FALLTHROUGH"); outc('\n'); @@ -254,14 +272,14 @@ int flex_main (int argc, char *argv[]) /* Copy remainder of input to output. */ - line_directive_out (stdout, infilename, linenum); + line_directive_out (stdout, gv->infilename, gv->linenum); - if (sectnum == 3) { + if (gv->sectnum == 3) { OUT_BEGIN_CODE (); - if (!ctrl.no_section3_escape) + if (!gv->ctrl.no_section3_escape) fputs("[[", stdout); (void) flexscan (); /* copy remainder of input to output */ - if (!ctrl.no_section3_escape) + if (!gv->ctrl.no_section3_escape) fputs("]]", stdout); OUT_END_CODE (); } @@ -295,17 +313,17 @@ void initialize_output_filters(void) { const char * m4 = NULL; - output_chain = filter_create_int(NULL, filter_tee_header, env.headerfilename); + gv->output_chain = filter_create_int(NULL, filter_tee_header, gv->env.headerfilename); if ( !(m4 = getenv("M4"))) { m4 = M4; } - filter_create_ext(output_chain, m4, "-P", (char *) 0); - filter_create_int(output_chain, filter_fix_linedirs, NULL); + filter_create_ext(gv->output_chain, m4, "-P", (char *) 0); + filter_create_int(gv->output_chain, filter_fix_linedirs, NULL); /* For debugging, only run the requested number of filters. */ - if (preproc_level > 0) { - filter_truncate(output_chain, preproc_level); - filter_apply_chain(output_chain); + if (gv->preproc_level > 0) { + filter_truncate(gv->output_chain, gv->preproc_level); + filter_apply_chain(gv->output_chain); } } @@ -316,116 +334,116 @@ void check_options (void) { int i; - if (ctrl.lex_compat) { - if (ctrl.C_plus_plus) + if (gv->ctrl.lex_compat) { + if (gv->ctrl.C_plus_plus) flexerror (_("Can't use -+ with -l option")); - if (ctrl.fulltbl || ctrl.fullspd) + if (gv->ctrl.fulltbl || gv->ctrl.fullspd) flexerror (_("Can't use -f or -F with -l option")); - if (ctrl.reentrant || ctrl.bison_bridge_lval) + if (gv->ctrl.reentrant || gv->ctrl.bison_bridge_lval) flexerror (_ ("Can't use --ctrl.reentrant or --bison-bridge with -l option")); - ctrl.yytext_is_array = true; - ctrl.do_yylineno = true; - ctrl.use_read = false; + gv->ctrl.yytext_is_array = true; + gv->ctrl.do_yylineno = true; + gv->ctrl.use_read = false; } #if 0 /* This makes no sense whatsoever. I'm removing it. */ - if (ctrl.do_yylineno) + if (gv->ctrl.do_yylineno) /* This should really be "maintain_backup_tables = true" */ - ctrl.reject_really_used = true; + gv->ctrl.reject_really_used = true; #endif - if (ctrl.csize == trit_unspecified) { - if ((ctrl.fulltbl || ctrl.fullspd) && !ctrl.useecs) - ctrl.csize = DEFAULT_CSIZE; + if (gv->ctrl.csize == trit_unspecified) { + if ((gv->ctrl.fulltbl || gv->ctrl.fullspd) && !gv->ctrl.useecs) + gv->ctrl.csize = DEFAULT_CSIZE; else - ctrl.csize = CSIZE; + gv->ctrl.csize = CSIZE; } - if (ctrl.interactive == trit_unspecified) { - if (ctrl.fulltbl || ctrl.fullspd) - ctrl.interactive = trit_false; + if (gv->ctrl.interactive == trit_unspecified) { + if (gv->ctrl.fulltbl || gv->ctrl.fullspd) + gv->ctrl.interactive = trit_false; else - ctrl.interactive = trit_true; + gv->ctrl.interactive = trit_true; } - if (ctrl.fulltbl || ctrl.fullspd) { - if (ctrl.usemecs) + if (gv->ctrl.fulltbl || gv->ctrl.fullspd) { + if (gv->ctrl.usemecs) flexerror (_ ("-Cf/-CF and -Cm don't make sense together")); - if (ctrl.interactive != trit_false) + if (gv->ctrl.interactive != trit_false) flexerror (_("-Cf/-CF and -I are incompatible")); - if (ctrl.lex_compat) + if (gv->ctrl.lex_compat) flexerror (_ ("-Cf/-CF are incompatible with lex-compatibility mode")); - if (ctrl.fulltbl && ctrl.fullspd) + if (gv->ctrl.fulltbl && gv->ctrl.fullspd) flexerror (_ ("-Cf and -CF are mutually exclusive")); } - if (ctrl.C_plus_plus && ctrl.fullspd) + if (gv->ctrl.C_plus_plus && gv->ctrl.fullspd) flexerror (_("Can't use -+ with -CF option")); - if (ctrl.C_plus_plus && ctrl.yytext_is_array) { + if (gv->ctrl.C_plus_plus && gv->ctrl.yytext_is_array) { lwarn (_("%array incompatible with -+ option")); - ctrl.yytext_is_array = false; + gv->ctrl.yytext_is_array = false; } - if (ctrl.C_plus_plus && (ctrl.reentrant)) + if (gv->ctrl.C_plus_plus && (gv->ctrl.reentrant)) flexerror (_("Options -+ and --reentrant are mutually exclusive.")); - if (ctrl.C_plus_plus && ctrl.bison_bridge_lval) + if (gv->ctrl.C_plus_plus && gv->ctrl.bison_bridge_lval) flexerror (_("bison bridge not supported for the C++ scanner.")); - if (ctrl.useecs) { /* Set up doubly-linked equivalence classes. */ + if (gv->ctrl.useecs) { /* Set up doubly-linked equivalence classes. */ /* We loop all the way up to ctrl.csize, since ecgroup[ctrl.csize] is * the position used for NUL characters. */ - ecgroup[1] = NIL; + gv->ecgroup[1] = NIL; - for (i = 2; i <= ctrl.csize; ++i) { - ecgroup[i] = i - 1; - nextecm[i - 1] = i; + for (i = 2; i <= gv->ctrl.csize; ++i) { + gv->ecgroup[i] = i - 1; + gv->nextecm[i - 1] = i; } - nextecm[ctrl.csize] = NIL; + gv->nextecm[gv->ctrl.csize] = NIL; } else { /* Put everything in its own equivalence class. */ - for (i = 1; i <= ctrl.csize; ++i) { - ecgroup[i] = i; - nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */ + for (i = 1; i <= gv->ctrl.csize; ++i) { + gv->ecgroup[i] = i; + gv->nextecm[i] = BAD_SUBSCRIPT; /* to catch errors */ } } - if (!env.use_stdout) { + if (!gv->env.use_stdout) { FILE *prev_stdout; - if (!env.did_outfilename) { - snprintf (outfile_path, sizeof(outfile_path), outfile_template, - ctrl.prefix, suffix()); + if (!gv->env.did_outfilename) { + snprintf (gv->outfile_path, sizeof(gv->outfile_path), gv->outfile_template, + gv->ctrl.prefix, suffix()); - env.outfilename = outfile_path; + gv->env.outfilename = gv->outfile_path; } - prev_stdout = freopen (env.outfilename, "w+", stdout); + prev_stdout = freopen (gv->env.outfilename, "w+", stdout); if (prev_stdout == NULL) - lerr (_("could not create %s"), env.outfilename); + lerr (_("could not create %s"), gv->env.outfilename); - outfile_created = 1; + gv->outfile_created = 1; } } @@ -437,244 +455,244 @@ void check_options (void) void flexend (int exit_status) { - static int called_before = -1; /* prevent infinite recursion. */ + //static int called_before = -1; /* prevent infinite recursion. */ int tblsiz; - if (++called_before) + if (++gv->called_before) FLEX_EXIT (exit_status); - if (ctrl.yyclass != NULL && !ctrl.C_plus_plus) + if (gv->ctrl.yyclass != NULL && !gv->ctrl.C_plus_plus) flexerror (_("%option yyclass only meaningful for C++ scanners")); - if (skelfile != NULL) { - if (ferror (skelfile)) + if (gv->skelfile != NULL) { + if (ferror (gv->skelfile)) lerr (_("input error reading skeleton file %s"), - env.skelname); + gv->env.skelname); - else if (fclose (skelfile)) + else if (fclose (gv->skelfile)) lerr (_("error closing skeleton file %s"), - env.skelname); + gv->env.skelname); } - if (exit_status != 0 && outfile_created) { + if (exit_status != 0 && gv->outfile_created) { if (ferror (stdout)) lerr (_("error writing output file %s"), - env.outfilename); + gv->env.outfilename); - else if ((_stdout_closed = 1) && fclose (stdout)) + else if ((gv->_stdout_closed = 1) && fclose (stdout)) lerr (_("error closing output file %s"), - env.outfilename); + gv->env.outfilename); - else if (unlink (env.outfilename)) + else if (unlink (gv->env.outfilename)) lerr (_("error deleting output file %s"), - env.outfilename); + gv->env.outfilename); } - if (env.backing_up_report && ctrl.backing_up_file) { - if (num_backing_up == 0) - fprintf (ctrl.backing_up_file, _("No backing up.\n")); - else if (ctrl.fullspd || ctrl.fulltbl) - fprintf (ctrl.backing_up_file, + if (gv->env.backing_up_report && gv->ctrl.backing_up_file) { + if (gv->num_backing_up == 0) + fprintf (gv->ctrl.backing_up_file, _("No backing up.\n")); + else if (gv->ctrl.fullspd || gv->ctrl.fulltbl) + fprintf (gv->ctrl.backing_up_file, _ ("%d backing up (non-accepting) states.\n"), - num_backing_up); + gv->num_backing_up); else - fprintf (ctrl.backing_up_file, + fprintf (gv->ctrl.backing_up_file, _("Compressed tables always back up.\n")); - if (ferror (ctrl.backing_up_file)) + if (ferror (gv->ctrl.backing_up_file)) lerr (_("error writing backup file %s"), - backing_name); + gv->backing_name); - else if (fclose (ctrl.backing_up_file)) + else if (fclose (gv->ctrl.backing_up_file)) lerr (_("error closing backup file %s"), - backing_name); + gv->backing_name); } - if (env.printstats) { + if (gv->env.printstats) { fprintf (stderr, _("%s version %s usage statistics:\n"), - program_name, flex_version); + gv->program_name, flex_version); fprintf (stderr, _(" scanner options: -")); - if (ctrl.C_plus_plus) + if (gv->ctrl.C_plus_plus) putc ('+', stderr); - if (env.backing_up_report) + if (gv->env.backing_up_report) putc ('b', stderr); - if (ctrl.ddebug) + if (gv->ctrl.ddebug) putc ('d', stderr); if (sf_case_ins()) putc ('i', stderr); - if (ctrl.lex_compat) + if (gv->ctrl.lex_compat) putc ('l', stderr); - if (ctrl.posix_compat) + if (gv->ctrl.posix_compat) putc ('X', stderr); - if (env.performance_hint > 0) + if (gv->env.performance_hint > 0) putc ('p', stderr); - if (env.performance_hint > 1) + if (gv->env.performance_hint > 1) putc ('p', stderr); - if (ctrl.spprdflt) + if (gv->ctrl.spprdflt) putc ('s', stderr); - if (ctrl.reentrant) + if (gv->ctrl.reentrant) fputs ("--reentrant", stderr); - if (ctrl.bison_bridge_lval) + if (gv->ctrl.bison_bridge_lval) fputs ("--bison-bridge", stderr); - if (ctrl.bison_bridge_lloc) + if (gv->ctrl.bison_bridge_lloc) fputs ("--bison-locations", stderr); - if (env.use_stdout) + if (gv->env.use_stdout) putc ('t', stderr); - if (env.printstats) + if (gv->env.printstats) putc ('v', stderr); /* always true! */ - if (env.nowarn) + if (gv->env.nowarn) putc ('w', stderr); - if (ctrl.interactive == trit_false) + if (gv->ctrl.interactive == trit_false) putc ('B', stderr); - if (ctrl.interactive == trit_true) + if (gv->ctrl.interactive == trit_true) putc ('I', stderr); - if (!ctrl.gen_line_dirs) + if (!gv->ctrl.gen_line_dirs) putc ('L', stderr); - if (env.trace) + if (gv->env.trace) putc ('T', stderr); - if (ctrl.csize == trit_unspecified) + if (gv->ctrl.csize == trit_unspecified) /* We encountered an error fairly early on, so ctrl.csize * never got specified. Define it now, to prevent * bogus table sizes being written out below. */ - ctrl.csize = 256; + gv->ctrl.csize = 256; - if (ctrl.csize == 128) + if (gv->ctrl.csize == 128) putc ('7', stderr); else putc ('8', stderr); fprintf (stderr, " -C"); - if (ctrl.long_align) + if (gv->ctrl.long_align) putc ('a', stderr); - if (ctrl.fulltbl) + if (gv->ctrl.fulltbl) putc ('f', stderr); - if (ctrl.fullspd) + if (gv->ctrl.fullspd) putc ('F', stderr); - if (ctrl.useecs) + if (gv->ctrl.useecs) putc ('e', stderr); - if (ctrl.usemecs) + if (gv->ctrl.usemecs) putc ('m', stderr); - if (ctrl.use_read) + if (gv->ctrl.use_read) putc ('r', stderr); - if (env.did_outfilename) - fprintf (stderr, " -o%s", env.outfilename); + if (gv->env.did_outfilename) + fprintf (stderr, " -o%s", gv->env.outfilename); - if (env.skelname != NULL) - fprintf (stderr, " -S%s", env.skelname); + if (gv->env.skelname != NULL) + fprintf (stderr, " -S%s", gv->env.skelname); - if (strcmp (ctrl.prefix, "yy")) - fprintf (stderr, " -P%s", ctrl.prefix); + if (strcmp (gv->ctrl.prefix, "yy")) + fprintf (stderr, " -P%s", gv->ctrl.prefix); putc ('\n', stderr); fprintf (stderr, _(" %d/%d NFA states\n"), - lastnfa, current_mns); + gv->lastnfa, gv->current_mns); fprintf (stderr, _(" %d/%d DFA states (%d words)\n"), - lastdfa, current_max_dfas, totnst); + gv->lastdfa, gv->current_max_dfas, gv->totnst); fprintf (stderr, _(" %d rules\n"), - num_rules + num_eof_rules - + gv->num_rules + gv->num_eof_rules - 1 /* - 1 for def. rule */ ); - if (num_backing_up == 0) + if (gv->num_backing_up == 0) fprintf (stderr, _(" No backing up\n")); - else if (ctrl.fullspd || ctrl.fulltbl) + else if (gv->ctrl.fullspd || gv->ctrl.fulltbl) fprintf (stderr, _ (" %d backing-up (non-accepting) states\n"), - num_backing_up); + gv->num_backing_up); else fprintf (stderr, _ (" Compressed tables always back-up\n")); - if (bol_needed) + if (gv->bol_needed) fprintf (stderr, _(" Beginning-of-line patterns used\n")); - fprintf (stderr, _(" %d/%d start conditions\n"), lastsc, - current_max_scs); + fprintf (stderr, _(" %d/%d start conditions\n"), gv->lastsc, + gv->current_max_scs); fprintf (stderr, _ (" %d epsilon states, %d double epsilon states\n"), - numeps, eps2); + gv->numeps, gv->eps2); - if (lastccl == 0) + if (gv->lastccl == 0) fprintf (stderr, _(" no character classes\n")); else fprintf (stderr, _ (" %d/%d character classes needed %d/%d words of storage, %d reused\n"), - lastccl, current_maxccls, - cclmap[lastccl] + ccllen[lastccl], - current_max_ccl_tbl_size, cclreuse); + gv->lastccl, gv->current_maxccls, + gv->cclmap[gv->lastccl] + gv->ccllen[gv->lastccl], + gv->current_max_ccl_tbl_size, gv->cclreuse); fprintf (stderr, _(" %d state/nextstate pairs created\n"), - numsnpairs); + gv->numsnpairs); fprintf (stderr, _(" %d/%d unique/duplicate transitions\n"), - numuniq, numdup); + gv->numuniq, gv->numdup); - if (ctrl.fulltbl) { - tblsiz = lastdfa * numecs; + if (gv->ctrl.fulltbl) { + tblsiz = gv->lastdfa * gv->numecs; fprintf (stderr, _(" %d table entries\n"), tblsiz); } else { - tblsiz = 2 * (lastdfa + numtemps) + 2 * tblend; + tblsiz = 2 * (gv->lastdfa + gv->numtemps) + 2 * gv->tblend; fprintf (stderr, _(" %d/%d base-def entries created\n"), - lastdfa + numtemps, current_max_dfas); + gv->lastdfa + gv->numtemps, gv->current_max_dfas); fprintf (stderr, _ (" %d/%d (peak %d) nxt-chk entries created\n"), - tblend, current_max_xpairs, peakpairs); + gv->tblend, gv->current_max_xpairs, gv->peakpairs); fprintf (stderr, _ (" %d/%d (peak %d) template nxt-chk entries created\n"), - numtemps * nummecs, - current_max_template_xpairs, - numtemps * numecs); + gv->numtemps * gv->nummecs, + gv->current_max_template_xpairs, + gv->numtemps * gv->numecs); fprintf (stderr, _(" %d empty table entries\n"), - nummt); + gv->nummt); fprintf (stderr, _(" %d protos created\n"), - numprots); + gv->numprots); fprintf (stderr, _(" %d templates created, %d uses\n"), - numtemps, tmpuses); + gv->numtemps, gv->tmpuses); } - if (ctrl.useecs) { - tblsiz = tblsiz + ctrl.csize; + if (gv->ctrl.useecs) { + tblsiz = tblsiz + gv->ctrl.csize; fprintf (stderr, _ (" %d/%d equivalence classes created\n"), - numecs, ctrl.csize); + gv->numecs, gv->ctrl.csize); } - if (ctrl.usemecs) { - tblsiz = tblsiz + numecs; + if (gv->ctrl.usemecs) { + tblsiz = tblsiz + gv->numecs; fprintf (stderr, _ (" %d/%d meta-equivalence classes created\n"), - nummecs, ctrl.csize); + gv->nummecs, gv->ctrl.csize); } fprintf (stderr, _ (" %d (%d saved) hash collisions, %d DFAs equal\n"), - hshcol, hshsave, dfaeql); + gv->hshcol, gv->hshsave, gv->dfaeql); fprintf (stderr, _(" %d sets of reallocations needed\n"), - num_reallocs); + gv->num_reallocs); fprintf (stderr, _(" %d total table entries needed\n"), tblsiz); } @@ -691,45 +709,45 @@ void flexinit (int argc, char **argv) char *arg; scanopt_t sopt; - memset(&ctrl, '\0', sizeof(ctrl)); - syntaxerror = false; - yymore_used = continued_action = false; - in_rule = reject = false; - ctrl.yymore_really_used = ctrl.reject_really_used = trit_unspecified; - - ctrl.do_main = trit_unspecified; - ctrl.interactive = ctrl.csize = trit_unspecified; - ctrl.do_yywrap = ctrl.gen_line_dirs = ctrl.usemecs = ctrl.useecs = true; - ctrl.reentrant = ctrl.bison_bridge_lval = ctrl.bison_bridge_lloc = false; - env.performance_hint = 0; - ctrl.prefix = "yy"; - ctrl.rewrite = false; - ctrl.yylmax = BUFSIZ; - - tablesext = tablesverify = false; - gentables = true; - tablesfilename = tablesname = NULL; + memset(&gv->ctrl, '\0', sizeof(gv->ctrl)); + gv->syntaxerror = false; + gv->yymore_used = gv->continued_action = false; + gv->in_rule = gv->reject = false; + gv->ctrl.yymore_really_used = gv->ctrl.reject_really_used = trit_unspecified; + + gv->ctrl.do_main = trit_unspecified; + gv->ctrl.interactive = gv->ctrl.csize = trit_unspecified; + gv->ctrl.do_yywrap = gv->ctrl.gen_line_dirs = gv->ctrl.usemecs = gv->ctrl.useecs = true; + gv->ctrl.reentrant = gv->ctrl.bison_bridge_lval = gv->ctrl.bison_bridge_lloc = false; + gv->env.performance_hint = 0; + gv->ctrl.prefix = "yy"; + gv->ctrl.rewrite = false; + gv->ctrl.yylmax = BUFSIZ; + + gv->tablesext = gv->tablesverify = false; + gv->gentables = true; + gv->tablesfilename = gv->tablesname = NULL; sawcmpflag = false; /* Initialize dynamic array for holding the rule actions. */ - action_size = 2048; /* default size of action array in bytes */ - action_array = allocate_character_array (action_size); - defs1_offset = prolog_offset = action_offset = action_index = 0; - action_array[0] = '\0'; + gv->action_size = 2048; /* default size of action array in bytes */ + gv->action_array = allocate_character_array (gv->action_size); + gv->defs1_offset = gv->prolog_offset = gv->action_offset = gv->action_index = 0; + gv->action_array[0] = '\0'; /* Initialize any buffers. */ - buf_init (&userdef_buf, sizeof (char)); /* one long string */ - buf_init (&top_buf, sizeof (char)); /* one long string */ + buf_init (&gv->userdef_buf, sizeof (char)); /* one long string */ + buf_init (&gv->top_buf, sizeof (char)); /* one long string */ sf_init (); /* Enable C++ if program name ends with '+'. */ - program_name = argv[0]; + gv->program_name = argv[0]; - if (program_name != NULL && - program_name[strlen (program_name) - 1] == '+') - ctrl.C_plus_plus = true; + if (gv->program_name != NULL && + gv->program_name[strlen (gv->program_name) - 1] == '+') + gv->ctrl.C_plus_plus = true; /* read flags */ sopt = scanopt_init (flexopts, argc, argv, 0); @@ -747,26 +765,26 @@ void flexinit (int argc, char **argv) fprintf (stderr, _ ("Try `%s --help' for more information.\n"), - program_name); + gv->program_name); FLEX_EXIT (1); } switch ((enum flexopt_flag_t) rv) { case OPT_CPLUSPLUS: - ctrl.C_plus_plus = true; + gv->ctrl.C_plus_plus = true; break; case OPT_BATCH: - ctrl.interactive = trit_false; + gv->ctrl.interactive = trit_false; break; case OPT_BACKUP: - env.backing_up_report = trit_true; + gv->env.backing_up_report = trit_true; break; case OPT_BACKUP_FILE: - env.backing_up_report = true; - backing_name = arg; + gv->env.backing_up_report = true; + gv->backing_name = arg; break; case OPT_DONOTHING: @@ -774,36 +792,36 @@ void flexinit (int argc, char **argv) case OPT_COMPRESSION: if (!sawcmpflag) { - ctrl.useecs = false; - ctrl.usemecs = false; - ctrl.fulltbl = false; + gv->ctrl.useecs = false; + gv->ctrl.usemecs = false; + gv->ctrl.fulltbl = false; sawcmpflag = true; } for (i = 0; arg && arg[i] != '\0'; i++) switch (arg[i]) { case 'a': - ctrl.long_align = true; + gv->ctrl.long_align = true; break; case 'e': - ctrl.useecs = true; + gv->ctrl.useecs = true; break; case 'F': - ctrl.fullspd = true; + gv->ctrl.fullspd = true; break; case 'f': - ctrl.fulltbl = true; + gv->ctrl.fulltbl = true; break; case 'm': - ctrl.usemecs = true; + gv->ctrl.usemecs = true; break; case 'r': - ctrl.use_read = true; + gv->ctrl.use_read = true; break; default: @@ -815,21 +833,21 @@ void flexinit (int argc, char **argv) break; case OPT_DEBUG: - ctrl.ddebug = true; + gv->ctrl.ddebug = true; break; case OPT_NO_DEBUG: - ctrl.ddebug = false; + gv->ctrl.ddebug = false; break; case OPT_FULL: - ctrl.useecs = ctrl.usemecs = false; - ctrl.use_read = ctrl.fulltbl = true; + gv->ctrl.useecs = gv->ctrl.usemecs = false; + gv->ctrl.use_read = gv->ctrl.fulltbl = true; break; case OPT_FAST: - ctrl.useecs = ctrl.usemecs = false; - ctrl.use_read = ctrl.fullspd = true; + gv->ctrl.useecs = gv->ctrl.usemecs = false; + gv->ctrl.use_read = gv->ctrl.fullspd = true; break; case OPT_HELP: @@ -837,7 +855,7 @@ void flexinit (int argc, char **argv) FLEX_EXIT (0); case OPT_INTERACTIVE: - ctrl.interactive = true; + gv->ctrl.interactive = true; break; case OPT_CASE_INSENSITIVE: @@ -845,162 +863,162 @@ void flexinit (int argc, char **argv) break; case OPT_LEX_COMPAT: - ctrl.lex_compat = true; + gv->ctrl.lex_compat = true; break; case OPT_POSIX_COMPAT: - ctrl.posix_compat = true; + gv->ctrl.posix_compat = true; break; case OPT_PREPROC_LEVEL: - preproc_level = (int) strtol(arg,NULL,0); + gv->preproc_level = (int) strtol(arg,NULL,0); break; case OPT_MAIN: - ctrl.do_yywrap = false; - ctrl.do_main = trit_true; + gv->ctrl.do_yywrap = false; + gv->ctrl.do_main = trit_true; break; case OPT_NO_MAIN: - ctrl.do_main = trit_false; + gv->ctrl.do_main = trit_false; break; case OPT_NO_LINE: - ctrl.gen_line_dirs = false; + gv->ctrl.gen_line_dirs = false; break; case OPT_OUTFILE: - env.outfilename = arg; - env.did_outfilename = 1; + gv->env.outfilename = arg; + gv->env.did_outfilename = 1; break; case OPT_PREFIX: - ctrl.prefix = arg; + gv->ctrl.prefix = arg; break; case OPT_PERF_REPORT: - ++env.performance_hint; + ++gv->env.performance_hint; break; case OPT_BISON_BRIDGE: - ctrl.bison_bridge_lval = true; + gv->ctrl.bison_bridge_lval = true; break; case OPT_BISON_BRIDGE_LOCATIONS: - ctrl.bison_bridge_lval = ctrl.bison_bridge_lloc = true; + gv->ctrl.bison_bridge_lval = gv->ctrl.bison_bridge_lloc = true; break; case OPT_REENTRANT: - ctrl.reentrant = true; + gv->ctrl.reentrant = true; break; case OPT_NO_REENTRANT: - ctrl.reentrant = false; + gv->ctrl.reentrant = false; break; case OPT_SKEL: - env.skelname = arg; + gv->env.skelname = arg; break; case OPT_DEFAULT: - ctrl.spprdflt = false; + gv->ctrl.spprdflt = false; break; case OPT_NO_DEFAULT: - ctrl.spprdflt = true; + gv->ctrl.spprdflt = true; break; case OPT_STDOUT: - env.use_stdout = true; + gv->env.use_stdout = true; break; case OPT_NO_UNISTD_H: - ctrl.no_unistd = true; + gv->ctrl.no_unistd = true; break; case OPT_TABLES_FILE: - tablesext = true; - tablesfilename = arg; + gv->tablesext = true; + gv->tablesfilename = arg; break; case OPT_TABLES_VERIFY: - tablesverify = true; + gv->tablesverify = true; break; case OPT_TRACE: - env.trace = true; + gv->env.trace = true; break; case OPT_VERBOSE: - env.printstats = true; + gv->env.printstats = true; break; case OPT_VERSION: - printf ("%s %s\n", (ctrl.C_plus_plus ? "flex++" : "flex"), flex_version); + printf ("%s %s\n", (gv->ctrl.C_plus_plus ? "flex++" : "flex"), flex_version); FLEX_EXIT (0); case OPT_WARN: - env.nowarn = false; + gv->env.nowarn = false; break; case OPT_NO_WARN: - env.nowarn = true; + gv->env.nowarn = true; break; case OPT_7BIT: - ctrl.csize = 128; + gv->ctrl.csize = 128; break; case OPT_8BIT: - ctrl.csize = CSIZE; + gv->ctrl.csize = CSIZE; break; case OPT_ALIGN: - ctrl.long_align = true; + gv->ctrl.long_align = true; break; case OPT_NO_ALIGN: - ctrl.long_align = false; + gv->ctrl.long_align = false; break; case OPT_ALWAYS_INTERACTIVE: - ctrl.always_interactive = true; + gv->ctrl.always_interactive = true; break; case OPT_NEVER_INTERACTIVE: - ctrl.never_interactive = true; + gv->ctrl.never_interactive = true; break; case OPT_ARRAY: - ctrl.yytext_is_array = true; + gv->ctrl.yytext_is_array = true; break; case OPT_POINTER: - ctrl.yytext_is_array = false; + gv->ctrl.yytext_is_array = false; break; case OPT_ECS: - ctrl.useecs = true; + gv->ctrl.useecs = true; break; case OPT_NO_ECS: - ctrl.useecs = false; + gv->ctrl.useecs = false; break; case OPT_EMIT: - ctrl.emit = arg; + gv->ctrl.emit = arg; break; case OPT_HEADER_FILE: - env.headerfilename = arg; + gv->env.headerfilename = arg; break; case OPT_META_ECS: - ctrl.usemecs = true; + gv->ctrl.usemecs = true; break; case OPT_NO_META_ECS: - ctrl.usemecs = false; + gv->ctrl.usemecs = false; break; case OPT_PREPROCDEFINE: @@ -1016,173 +1034,173 @@ void flexinit (int argc, char **argv) def = "1"; snprintf(buf2, sizeof(buf2), "M4_HOOK_CONST_DEFINE_UNKNOWN(%s, %s)", arg, def); - buf_strappend (&userdef_buf, buf2); + buf_strappend (&gv->userdef_buf, buf2); } break; case OPT_READ: - ctrl.use_read = true; + gv->ctrl.use_read = true; break; case OPT_STACK: - ctrl.stack_used = true; + gv->ctrl.stack_used = true; break; case OPT_STDINIT: - ctrl.do_stdinit = true; + gv->ctrl.do_stdinit = true; break; case OPT_NO_STDINIT: - ctrl.do_stdinit = false; + gv->ctrl.do_stdinit = false; break; case OPT_YYCLASS: - ctrl.yyclass = arg; + gv->ctrl.yyclass = arg; break; case OPT_YYLINENO: - ctrl.do_yylineno = true; + gv->ctrl.do_yylineno = true; break; case OPT_NO_YYLINENO: - ctrl.do_yylineno = false; + gv->ctrl.do_yylineno = false; break; case OPT_YYWRAP: - ctrl.do_yywrap = true; + gv->ctrl.do_yywrap = true; break; case OPT_NO_YYWRAP: - ctrl.do_yywrap = false; + gv->ctrl.do_yywrap = false; break; case OPT_YYMORE: - ctrl.yymore_really_used = true; + gv->ctrl.yymore_really_used = true; break; case OPT_NO_YYMORE: - ctrl.yymore_really_used = false; + gv->ctrl.yymore_really_used = false; break; case OPT_REJECT: - ctrl.reject_really_used = true; + gv->ctrl.reject_really_used = true; break; case OPT_NO_REJECT: - ctrl.reject_really_used = false; + gv->ctrl.reject_really_used = false; break; case OPT_NO_YY_PUSH_STATE: - ctrl.no_yy_push_state = true; + gv->ctrl.no_yy_push_state = true; break; case OPT_NO_YY_POP_STATE: - ctrl.no_yy_pop_state = true; + gv->ctrl.no_yy_pop_state = true; break; case OPT_NO_YY_TOP_STATE: - ctrl.no_yy_top_state = true; + gv->ctrl.no_yy_top_state = true; break; case OPT_NO_YYINPUT: - ctrl.no_yyinput = true; + gv->ctrl.no_yyinput = true; break; case OPT_NO_YYUNPUT: - ctrl.no_yyunput = true; + gv->ctrl.no_yyunput = true; break; case OPT_NO_YY_SCAN_BUFFER: - ctrl.no_yy_scan_buffer = true; + gv->ctrl.no_yy_scan_buffer = true; break; case OPT_NO_YY_SCAN_BYTES: - ctrl.no_yy_scan_bytes = true; + gv->ctrl.no_yy_scan_bytes = true; break; case OPT_NO_YY_SCAN_STRING: - ctrl.no_yy_scan_string = true; + gv->ctrl.no_yy_scan_string = true; break; case OPT_NO_YYGET_EXTRA: - ctrl.no_yyget_extra = true; + gv->ctrl.no_yyget_extra = true; break; case OPT_NO_YYSET_EXTRA: - ctrl.no_yyset_extra = true; + gv->ctrl.no_yyset_extra = true; break; case OPT_NO_YYGET_LENG: - ctrl.no_yyget_leng = true; + gv->ctrl.no_yyget_leng = true; break; case OPT_NO_YYGET_TEXT: - ctrl.no_yyget_text = true; + gv->ctrl.no_yyget_text = true; break; case OPT_NO_YYGET_LINENO: - ctrl.no_yyget_lineno = true; + gv->ctrl.no_yyget_lineno = true; break; case OPT_NO_YYSET_LINENO: - ctrl.no_yyset_lineno = true; + gv->ctrl.no_yyset_lineno = true; break; case OPT_NO_YYGET_COLUMN: - ctrl.no_yyget_column = true; + gv->ctrl.no_yyget_column = true; break; case OPT_NO_YYSET_COLUMN: - ctrl.no_yyset_column = true; + gv->ctrl.no_yyset_column = true; break; case OPT_NO_YYGET_IN: - ctrl.no_yyget_in = true; + gv->ctrl.no_yyget_in = true; break; case OPT_NO_YYSET_IN: - ctrl.no_yyset_in = true; + gv->ctrl.no_yyset_in = true; break; case OPT_NO_YYGET_OUT: - ctrl.no_yyget_out = true; + gv->ctrl.no_yyget_out = true; break; case OPT_NO_YYSET_OUT: - ctrl.no_yyset_out = true; + gv->ctrl.no_yyset_out = true; break; case OPT_NO_YYGET_LVAL: - ctrl.no_yyget_lval = true; + gv->ctrl.no_yyget_lval = true; break; case OPT_NO_YYSET_LVAL: - ctrl.no_yyset_lval = true; + gv->ctrl.no_yyset_lval = true; break; case OPT_NO_YYGET_LLOC: - ctrl.no_yyget_lloc = true; + gv->ctrl.no_yyget_lloc = true; break; case OPT_NO_YYSET_LLOC: - ctrl.no_yyset_lloc = true; + gv->ctrl.no_yyset_lloc = true; break; case OPT_NO_YYGET_DEBUG: - ctrl.no_get_debug = true; + gv->ctrl.no_get_debug = true; break; case OPT_NO_YYSET_DEBUG: - ctrl.no_set_debug = true; + gv->ctrl.no_set_debug = true; break; case OPT_HEX: - env.trace_hex = true; + gv->env.trace_hex = true; break; case OPT_NO_SECT3_ESCAPE: - ctrl.no_section3_escape = true; + gv->ctrl.no_section3_escape = true; break; } /* switch */ } /* while scanopt() */ scanopt_destroy (sopt); - num_input_files = argc - optind; - input_files = argv + optind; - set_input_file (num_input_files > 0 ? input_files[0] : NULL); + gv->num_input_files = argc - optind; + gv->input_files = argv + optind; + set_input_file (gv->num_input_files > 0 ? gv->input_files[0] : NULL); - lastccl = lastsc = lastdfa = lastnfa = 0; - num_rules = num_eof_rules = default_rule = 0; - numas = numsnpairs = tmpuses = 0; - numecs = numeps = eps2 = num_reallocs = hshcol = dfaeql = totnst = + gv->lastccl = gv->lastsc = gv->lastdfa = gv->lastnfa = 0; + gv->num_rules = gv->num_eof_rules = gv->default_rule = 0; + gv->numas = gv->numsnpairs = gv->tmpuses = 0; + gv->numecs = gv->numeps = gv->eps2 = gv->num_reallocs = gv->hshcol = gv->dfaeql = gv->totnst = 0; - numuniq = numdup = hshsave = datapos = dataline = 0; - eofseen = false; - num_backing_up = onesp = numprots = 0; - variable_trailing_context_rules = bol_needed = false; + gv->numuniq = gv->numdup = gv->hshsave = gv->datapos = gv->dataline = 0; + gv->eofseen = false; + gv->num_backing_up = gv->onesp = gv->numprots = 0; + gv->variable_trailing_context_rules = gv->bol_needed = false; - linenum = sectnum = 1; - firstprot = NIL; + gv->linenum = gv->sectnum = 1; + gv->firstprot = NIL; /* Used in mkprot() so that the first proto goes in slot 1 * of the proto queue. */ - lastprot = 1; + gv->lastprot = 1; set_up_initial_allocations (); } @@ -1194,14 +1212,14 @@ void readin (void) { char buf[256]; - line_directive_out(NULL, infilename, linenum); + line_directive_out(NULL, gv->infilename, gv->linenum); if (yyparse ()) { pinpoint_message (_("fatal parse error")); flexend (1); } - if (syntaxerror) + if (gv->syntaxerror) flexend (1); /* On --emit, -e, or change backends This is where backend @@ -1210,56 +1228,56 @@ void readin (void) * when %option emit was evaluated; this catches command-line * optiins and the default case. */ - backend_by_name(ctrl.emit); + backend_by_name(gv->ctrl.emit); initialize_output_filters(); yyout = stdout; - if (tablesext) - gentables = false; + if (gv->tablesext) + gv->gentables = false; - if (tablesverify) + if (gv->tablesverify) /* force generation of C tables. */ - gentables = true; + gv->gentables = true; - if (tablesext) { + if (gv->tablesext) { FILE *tablesout; struct yytbl_hdr hdr; char *pname = 0; size_t nbytes = 0; - if (!tablesfilename) { - nbytes = strlen (ctrl.prefix) + strlen (tablesfile_template) + 2; - tablesfilename = pname = calloc(nbytes, 1); - snprintf (pname, nbytes, tablesfile_template, ctrl.prefix); + if (!gv->tablesfilename) { + nbytes = strlen (gv->ctrl.prefix) + strlen (gv->tablesfile_template) + 2; + gv->tablesfilename = pname = calloc(nbytes, 1); + snprintf (pname, nbytes, gv->tablesfile_template, gv->ctrl.prefix); } - if ((tablesout = fopen (tablesfilename, "w")) == NULL) - lerr (_("could not create %s"), tablesfilename); + if ((tablesout = fopen (gv->tablesfilename, "w")) == NULL) + lerr (_("could not create %s"), gv->tablesfilename); free(pname); - tablesfilename = 0; + gv->tablesfilename = 0; - yytbl_writer_init (&tableswr, tablesout); + yytbl_writer_init (&gv->tableswr, tablesout); - nbytes = strlen (ctrl.prefix) + strlen ("tables") + 2; - tablesname = calloc(nbytes, 1); - snprintf (tablesname, nbytes, "%stables", ctrl.prefix); - yytbl_hdr_init (&hdr, flex_version, tablesname); + nbytes = strlen (gv->ctrl.prefix) + strlen ("tables") + 2; + gv->tablesname = calloc(nbytes, 1); + snprintf (gv->tablesname, nbytes, "%stables", gv->ctrl.prefix); + yytbl_hdr_init (&hdr, flex_version, gv->tablesname); - if (yytbl_hdr_fwrite (&tableswr, &hdr) <= 0) + if (yytbl_hdr_fwrite (&gv->tableswr, &hdr) <= 0) flexerror (_("could not write tables header")); } - if (env.skelname && (skelfile = fopen (env.skelname, "r")) == NULL) - lerr (_("can't open skeleton file %s"), env.skelname); + if (gv->env.skelname && (gv->skelfile = fopen (gv->env.skelname, "r")) == NULL) + lerr (_("can't open skeleton file %s"), gv->env.skelname); - if (strchr(ctrl.prefix, '[') || strchr(ctrl.prefix, ']')) + if (strchr(gv->ctrl.prefix, '[') || strchr(gv->ctrl.prefix, ']')) flexerror(_("Prefix cannot include '[' or ']'")); - if (env.did_outfilename) - line_directive_out (stdout, NULL, linenum); + if (gv->env.did_outfilename) + line_directive_out (stdout, NULL, gv->linenum); /* This is where we begin writing to the file. */ @@ -1268,36 +1286,36 @@ void readin (void) comment("A lexical scanner generated by flex\n"); /* Dump the %top code. */ - if( top_buf.elts) - outn((char*) top_buf.elts); + if( gv->top_buf.elts) + outn((char*) gv->top_buf.elts); /* Place a bogus line directive, it will be fixed in the filter. */ line_directive_out(NULL, NULL, 0); /* User may want to set the scanner prototype */ - if (ctrl.yydecl != NULL) { - out_str ("M4_HOOK_SET_YY_DECL(%s)\n", ctrl.yydecl); + if (gv->ctrl.yydecl != NULL) { + out_str ("M4_HOOK_SET_YY_DECL(%s)\n", gv->ctrl.yydecl); } - if (ctrl.userinit != NULL) { - out_str ("M4_HOOK_SET_USERINIT(%s)\n", ctrl.userinit); + if (gv->ctrl.userinit != NULL) { + out_str ("M4_HOOK_SET_USERINIT(%s)\n", gv->ctrl.userinit); } - if (ctrl.preaction != NULL) { - out_str ("M4_HOOK_SET_PREACTION(%s)\n", ctrl.preaction); + if (gv->ctrl.preaction != NULL) { + out_str ("M4_HOOK_SET_PREACTION(%s)\n", gv->ctrl.preaction); } - if (ctrl.postaction != NULL) { - out_str ("M4_HOOK_SET_POSTACTION(%s)\n", ctrl.postaction); + if (gv->ctrl.postaction != NULL) { + out_str ("M4_HOOK_SET_POSTACTION(%s)\n", gv->ctrl.postaction); } /* This has to be a straight textual substitution rather * than a constant declaration because in C a const is * not const enough to be a static array bound. */ - out_dec ("m4_define([[YYLMAX]], [[%d]])\n", ctrl.yylmax); + out_dec ("m4_define([[YYLMAX]], [[%d]])\n", gv->ctrl.yylmax); /* Dump the user defined preproc directives. */ - if (userdef_buf.elts) - outn ((char *) (userdef_buf.elts)); + if (gv->userdef_buf.elts) + outn ((char *) (gv->userdef_buf.elts)); /* If the user explicitly requested posix compatibility by specifying the * posix-compat option, then we check for conflicting options. However, if @@ -1308,7 +1326,7 @@ void readin (void) * Note: The posix option was added to flex to provide the posix behavior * of the repeat operator in regular expressions, e.g., `ab{3}' */ - if (ctrl.posix_compat) { + if (gv->ctrl.posix_compat) { /* TODO: This is where we try to make flex behave according to * POSIX, *and* check for conflicting ctrl. How far should we go * with this? Should we disable all the neat-o flex features? @@ -1317,32 +1335,32 @@ void readin (void) } if (getenv ("POSIXLY_CORRECT")) { - ctrl.posix_compat = true; + gv->ctrl.posix_compat = true; } - if (env.backing_up_report) { - ctrl.backing_up_file = fopen (backing_name, "w"); - if (ctrl.backing_up_file == NULL) + if (gv->env.backing_up_report) { + gv->ctrl.backing_up_file = fopen (gv->backing_name, "w"); + if (gv->ctrl.backing_up_file == NULL) lerr (_ ("could not create backing-up info file %s"), - backing_name); + gv->backing_name); } else - ctrl.backing_up_file = NULL; + gv->ctrl.backing_up_file = NULL; - if (ctrl.yymore_really_used == true) - yymore_used = true; - else if (ctrl.yymore_really_used == false) - yymore_used = false; + if (gv->ctrl.yymore_really_used == true) + gv->yymore_used = true; + else if (gv->ctrl.yymore_really_used == false) + gv->yymore_used = false; - if (ctrl.reject_really_used == true) - reject = true; - else if (ctrl.reject_really_used == false) - reject = false; + if (gv->ctrl.reject_really_used == true) + gv->reject = true; + else if (gv->ctrl.reject_really_used == false) + gv->reject = false; - if (env.performance_hint > 0) { - if (ctrl.lex_compat) { + if (gv->env.performance_hint > 0) { + if (gv->ctrl.lex_compat) { fprintf (stderr, _ ("-l AT&T lex compatibility option entails a large performance penalty\n")); @@ -1351,46 +1369,46 @@ void readin (void) (" and may be the actual source of other reported performance penalties\n")); } - else if (ctrl.do_yylineno) { + else if (gv->ctrl.do_yylineno) { fprintf (stderr, _ ("%%option yylineno entails a performance penalty ONLY on rules that can match newline characters\n")); } - if (env.performance_hint > 1) { - if (ctrl.interactive == trit_true) + if (gv->env.performance_hint > 1) { + if (gv->ctrl.interactive == trit_true) fprintf (stderr, _ ("-I (interactive) entails a minor performance penalty\n")); - if (yymore_used) + if (gv->yymore_used) fprintf (stderr, _ ("yymore() entails a minor performance penalty\n")); } - if (reject) + if (gv->reject) fprintf (stderr, _ ("REJECT entails a large performance penalty\n")); - if (variable_trailing_context_rules) + if (gv->variable_trailing_context_rules) fprintf (stderr, _ ("Variable trailing context rules entail a large performance penalty\n")); } - if (reject) - real_reject = true; + if (gv->reject) + gv->real_reject = true; - if (variable_trailing_context_rules) - reject = true; + if (gv->variable_trailing_context_rules) + gv->reject = true; - if ((ctrl.fulltbl || ctrl.fullspd) && reject) { - if (real_reject) + if ((gv->ctrl.fulltbl || gv->ctrl.fullspd) && gv->reject) { + if (gv->real_reject) flexerror (_ ("REJECT cannot be used with -f or -F")); - else if (ctrl.do_yylineno) + else if (gv->ctrl.do_yylineno) flexerror (_ ("%option yylineno cannot be used with REJECT")); else @@ -1398,23 +1416,23 @@ void readin (void) ("variable trailing context rules cannot be used with -f or -F")); } - if (ctrl.useecs) - numecs = cre8ecs (nextecm, ecgroup, ctrl.csize); + if (gv->ctrl.useecs) + gv->numecs = cre8ecs (gv->nextecm, gv->ecgroup, gv->ctrl.csize); else - numecs = ctrl.csize; + gv->numecs = gv->ctrl.csize; /* Now map the equivalence class for NUL to its expected place. */ - ecgroup[0] = ecgroup[ctrl.csize]; - NUL_ec = ABS (ecgroup[0]); + gv->ecgroup[0] = gv->ecgroup[gv->ctrl.csize]; + gv->NUL_ec = ABS (gv->ecgroup[0]); - if (ctrl.useecs) + if (gv->ctrl.useecs) ccl2ecl (); // These are used to conditionalize code in the lex skeleton // that historically used to be generated by C code in flex // itself; by shoving all this stuff out to the skeleton file // we make it easier to retarget the code generation. - snprintf(buf, sizeof(buf), "Target: %s\n", ctrl.backend_name); + snprintf(buf, sizeof(buf), "Target: %s\n", gv->ctrl.backend_name); comment(buf); comment("START of m4 controls\n"); @@ -1423,15 +1441,15 @@ void readin (void) struct Buf tmpbuf; int i; buf_init(&tmpbuf, sizeof(char)); - for (i = 1; i <= lastsc; i++) { + for (i = 1; i <= gv->lastsc; i++) { char *str, *fmt = "M4_HOOK_CONST_DEFINE_STATE(%s, %d)"; size_t strsz; - strsz = strlen(fmt) + strlen(scname[i]) + (size_t)(1 + ceil (log10(i))) + 2; + strsz = strlen(fmt) + strlen(gv->scname[i]) + (size_t)(1 + ceil (log10(i))) + 2; str = malloc(strsz); if (!str) flexfatal(_("allocation of macro definition failed")); - snprintf(str, strsz, fmt, scname[i], i - 1); + snprintf(str, strsz, fmt, gv->scname[i], i - 1); buf_strappend(&tmpbuf, str); free(str); } @@ -1440,235 +1458,235 @@ void readin (void) buf_destroy(&tmpbuf); } - if (ctrl.bison_bridge_lval) + if (gv->ctrl.bison_bridge_lval) visible_define("M4_YY_BISON_LVAL"); - if (ctrl.bison_bridge_lloc) + if (gv->ctrl.bison_bridge_lloc) visible_define(""); - if (extra_type != NULL) - visible_define_str ("M4_MODE_EXTRA_TYPE", extra_type); + if (gv->extra_type != NULL) + visible_define_str ("M4_MODE_EXTRA_TYPE", gv->extra_type); /* always generate the tablesverify flag. */ - visible_define_str ("M4_YY_TABLES_VERIFY", tablesverify ? "1" : "0"); + visible_define_str ("M4_YY_TABLES_VERIFY", gv->tablesverify ? "1" : "0"); - if (ctrl.reentrant) { + if (gv->ctrl.reentrant) { visible_define ("M4_YY_REENTRANT"); - if (ctrl.yytext_is_array) + if (gv->ctrl.yytext_is_array) visible_define ("M4_MODE_REENTRANT_TEXT_IS_ARRAY"); } - if (ctrl.do_main == trit_true) + if (gv->ctrl.do_main == trit_true) visible_define_str ( "YY_MAIN", "1"); - else if (ctrl.do_main == trit_false) + else if (gv->ctrl.do_main == trit_false) visible_define_str ( "YY_MAIN", "0"); - if (ctrl.do_stdinit) + if (gv->ctrl.do_stdinit) visible_define ( "M4_MODE_DO_STDINIT"); else visible_define ( "M4_MODE_NO_DO_STDINIT"); // mode switches for YY_DO_BEFORE_ACTION code generation - if (ctrl.yytext_is_array) + if (gv->ctrl.yytext_is_array) visible_define ( "M4_MODE_YYTEXT_IS_ARRAY"); else visible_define ( "M4_MODE_NO_YYTEXT_IS_ARRAY"); - if (yymore_used) + if (gv->yymore_used) visible_define ( "M4_MODE_YYMORE_USED"); else visible_define ( "M4_MODE_NO_YYMORE_USED"); - if (ctrl.fullspd) + if (gv->ctrl.fullspd) visible_define ( "M4_MODE_REAL_FULLSPD"); else visible_define ( "M4_MODE_NO_REAL_FULLSPD"); - if (ctrl.fulltbl) + if (gv->ctrl.fulltbl) visible_define ( "M4_MODE_REAL_FULLTBL"); else visible_define ( "M4_MODE_NO_REAL_FULLTBL"); // niode switches for YYINPUT code generation - if (ctrl.use_read) + if (gv->ctrl.use_read) visible_define ( "M4_MODE_CPP_USE_READ"); else visible_define ( "M4_MODE_NO_CPP_USE_READ"); // mode switches for next-action code - if (variable_trailing_context_rules) { + if (gv->variable_trailing_context_rules) { visible_define ( "M4_MODE_VARIABLE_TRAILING_CONTEXT_RULES"); } else { visible_define ( "M4_MODE_NO_VARIABLE_TRAILING_CONTEXT_RULES"); } - if (real_reject) + if (gv->real_reject) visible_define ( "M4_MODE_REAL_REJECT"); - if (ctrl.reject_really_used) + if (gv->ctrl.reject_really_used) visible_define ( "M4_MODE_FIND_ACTION_REJECT_REALLY_USED"); - if (reject) + if (gv->reject) visible_define ( "M4_MODE_USES_REJECT"); else visible_define ( "M4_MODE_NO_USES_REJECT"); // mode switches for computing next compressed state - if (ctrl.usemecs) + if (gv->ctrl.usemecs) visible_define ( "M4_MODE_USEMECS"); // mode switches for find-action code - if (ctrl.fullspd) + if (gv->ctrl.fullspd) visible_define ( "M4_MODE_FULLSPD"); - else if (ctrl.fulltbl) + else if (gv->ctrl.fulltbl) visible_define ( "M4_MODE_FIND_ACTION_FULLTBL"); - else if (reject) + else if (gv->reject) visible_define ( "M4_MODE_FIND_ACTION_REJECT"); else visible_define ( "M4_MODE_FIND_ACTION_COMPRESSED"); // mode switches for backup generation and gen_start_state - if (!ctrl.fullspd) + if (!gv->ctrl.fullspd) visible_define ( "M4_MODE_NO_FULLSPD"); - if (bol_needed) + if (gv->bol_needed) visible_define ( "M4_MODE_BOL_NEEDED"); else visible_define ( "M4_MODE_NO_BOL_NEEDED"); // yylineno - if (ctrl.do_yylineno) + if (gv->ctrl.do_yylineno) visible_define ( "M4_MODE_YYLINENO"); // Equivalence classes - if (ctrl.useecs) + if (gv->ctrl.useecs) visible_define ( "M4_MODE_USEECS"); else visible_define ( "M4_MODE_NO_USEECS"); // mode switches for getting next action - if (gentables) + if (gv->gentables) visible_define ( "M4_MODE_GENTABLES"); else visible_define ( "M4_MODE_NO_GENTABLES"); - if (ctrl.interactive == trit_true) + if (gv->ctrl.interactive == trit_true) visible_define ( "M4_MODE_INTERACTIVE"); else visible_define ( "M4_MODE_NO_INTERACTIVE"); - if (!(ctrl.fullspd || ctrl.fulltbl)) + if (!(gv->ctrl.fullspd || gv->ctrl.fulltbl)) visible_define ( "M4_MODE_NO_FULLSPD_OR_FULLTBL"); - if (reject || ctrl.interactive == trit_true) + if (gv->reject || gv->ctrl.interactive == trit_true) visible_define ( "M4_MODE_FIND_ACTION_REJECT_OR_INTERACTIVE"); - if (ctrl.yyclass != NULL) { + if (gv->ctrl.yyclass != NULL) { visible_define ( "M4_MODE_YYCLASS"); - out_m4_define("M4_YY_CLASS_NAME", ctrl.yyclass); + out_m4_define("M4_YY_CLASS_NAME", gv->ctrl.yyclass); } - if (ctrl.ddebug) + if (gv->ctrl.ddebug) visible_define ( "M4_MODE_DEBUG"); - if (ctrl.lex_compat) + if (gv->ctrl.lex_compat) visible_define ( "M4_MODE_OPTIONS.LEX_COMPAT"); - if (ctrl.do_yywrap) + if (gv->ctrl.do_yywrap) visible_define ( "M4_MODE_YYWRAP"); else visible_define ( "M4_MODE_NO_YYWRAP"); - if (ctrl.interactive == trit_true) + if (gv->ctrl.interactive == trit_true) visible_define ( "M4_MODE_INTERACTIVE"); - if (ctrl.noyyread) + if (gv->ctrl.noyyread) visible_define("M4_MODE_USER_YYREAD"); if (is_default_backend()) { - if (ctrl.C_plus_plus) { + if (gv->ctrl.C_plus_plus) { visible_define ( "M4_MODE_CXX_ONLY"); } else { visible_define ( "M4_MODE_C_ONLY"); } } - if (tablesext) + if (gv->tablesext) visible_define ( "M4_MODE_TABLESEXT"); - if (ctrl.prefix != NULL) - visible_define_str ( "M4_MODE_PREFIX", ctrl.prefix); + if (gv->ctrl.prefix != NULL) + visible_define_str ( "M4_MODE_PREFIX", gv->ctrl.prefix); - if (ctrl.no_yyinput) + if (gv->ctrl.no_yyinput) visible_define("M4_MODE_NO_YYINPUT"); - if (ctrl.bufsize != 0) - visible_define_int("M4_MODE_YY_BUFSIZE", ctrl.bufsize); + if (gv->ctrl.bufsize != 0) + visible_define_int("M4_MODE_YY_BUFSIZE", gv->ctrl.bufsize); - if (ctrl.yyterminate != NULL) - visible_define_str("M4_MODE_YYTERMINATE", ctrl.yyterminate); + if (gv->ctrl.yyterminate != NULL) + visible_define_str("M4_MODE_YYTERMINATE", gv->ctrl.yyterminate); - if (ctrl.no_yypanic) + if (gv->ctrl.no_yypanic) visible_define("M4_YY_NO_YYPANIC"); - if (ctrl.no_yy_push_state) + if (gv->ctrl.no_yy_push_state) visible_define("M4_YY_NO_PUSH_STATE"); - if (ctrl.no_yy_pop_state) + if (gv->ctrl.no_yy_pop_state) visible_define("M4_YY_NO_POP_STATE"); - if (ctrl.no_yy_top_state) + if (gv->ctrl.no_yy_top_state) visible_define("M4_YY_NO_TOP_STATE"); - if (ctrl.no_yyunput) + if (gv->ctrl.no_yyunput) visible_define("M4_YY_NO_YYUNPUT"); - if (ctrl.no_yy_scan_buffer) + if (gv->ctrl.no_yy_scan_buffer) visible_define("M4_YY_NO_SCAN_BUFFER"); - if (ctrl.no_yy_scan_bytes) + if (gv->ctrl.no_yy_scan_bytes) visible_define("M4_YY_NO_SCAN_BYTES"); - if (ctrl.no_yy_scan_string) + if (gv->ctrl.no_yy_scan_string) visible_define("M4_YY_NO_SCAN_STRING"); - if (ctrl.no_yyget_extra) + if (gv->ctrl.no_yyget_extra) visible_define("M4_YY_NO_GET_EXTRA"); - if (ctrl.no_yyset_extra) + if (gv->ctrl.no_yyset_extra) visible_define("M4_YY_NO_SET_EXTRA"); - if (ctrl.no_yyget_leng) + if (gv->ctrl.no_yyget_leng) visible_define("M4_YY_NO_GET_LENG"); - if (ctrl.no_yyget_text) + if (gv->ctrl.no_yyget_text) visible_define("M4_YY_NO_GET_TEXT"); - if (ctrl.no_yyget_lineno) + if (gv->ctrl.no_yyget_lineno) visible_define("M4_YY_NO_GET_LINENO"); - if (ctrl.no_yyset_lineno) + if (gv->ctrl.no_yyset_lineno) visible_define("M4_YY_NO_SET_LINENO"); - if (ctrl.no_yyget_column) + if (gv->ctrl.no_yyget_column) visible_define("M4_YY_NO_GET_COLUMN"); - if (ctrl.no_yyset_column) + if (gv->ctrl.no_yyset_column) visible_define("M4_YY_NO_SET_COLUMN"); - if (ctrl.no_yyget_in) + if (gv->ctrl.no_yyget_in) visible_define("M4_YY_NO_GET_IN"); - if (ctrl.no_yyset_in) + if (gv->ctrl.no_yyset_in) visible_define("M4_YY_NO_SET_IN"); - if (ctrl.no_yyget_out) + if (gv->ctrl.no_yyget_out) visible_define("M4_YY_NO_GET_OUT"); - if (ctrl.no_yyset_out) + if (gv->ctrl.no_yyset_out) visible_define("M4_YY_NO_SET_OUT"); - if (ctrl.no_yyget_lval) + if (gv->ctrl.no_yyget_lval) visible_define("M4_YY_NO_GET_LVAL"); - if (ctrl.no_yyset_lval) + if (gv->ctrl.no_yyset_lval) visible_define("M4_YY_NO_SET_LVAL"); - if (ctrl.no_yyget_lloc) + if (gv->ctrl.no_yyget_lloc) visible_define("M4_YY_NO_GET_LLOC"); - if (ctrl.no_yyset_lloc) + if (gv->ctrl.no_yyset_lloc) visible_define("M4_YY_NO_SET_LLOC"); - if (ctrl.no_flex_alloc) + if (gv->ctrl.no_flex_alloc) visible_define("M4_YY_NO_FLEX_ALLOC"); - if (ctrl.no_flex_realloc) + if (gv->ctrl.no_flex_realloc) visible_define("M4_YY_NO_FLEX_REALLOC"); - if (ctrl.no_flex_free) + if (gv->ctrl.no_flex_free) visible_define("M4_YY_NO_FLEX_FREE"); - if (ctrl.no_get_debug) + if (gv->ctrl.no_get_debug) visible_define("M4_YY_NO_GET_DEBUG"); - if (ctrl.no_set_debug) + if (gv->ctrl.no_set_debug) visible_define("M4_YY_NO_SET_DEBUG"); - if (ctrl.no_unistd) + if (gv->ctrl.no_unistd) visible_define("M4_YY_NO_UNISTD_H"); - if (ctrl.always_interactive) + if (gv->ctrl.always_interactive) visible_define("M4_YY_ALWAYS_INTERACTIVE"); - if (ctrl.never_interactive) + if (gv->ctrl.never_interactive) visible_define("M4_YY_NEVER_INTERACTIVE"); - if (ctrl.stack_used) + if (gv->ctrl.stack_used) visible_define("M4_YY_STACK_USED"); - if (ctrl.rewrite) + if (gv->ctrl.rewrite) visible_define ( "M4_MODE_REWRITE"); else visible_define ( "M4_MODE_NO_REWRITE"); @@ -1681,60 +1699,60 @@ void readin (void) void set_up_initial_allocations (void) { - maximum_mns = (ctrl.long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS); - current_mns = INITIAL_MNS; - firstst = allocate_integer_array (current_mns); - lastst = allocate_integer_array (current_mns); - finalst = allocate_integer_array (current_mns); - transchar = allocate_integer_array (current_mns); - trans1 = allocate_integer_array (current_mns); - trans2 = allocate_integer_array (current_mns); - accptnum = allocate_integer_array (current_mns); - assoc_rule = allocate_integer_array (current_mns); - state_type = allocate_integer_array (current_mns); - - current_max_rules = INITIAL_MAX_RULES; - rule_type = allocate_integer_array (current_max_rules); - rule_linenum = allocate_integer_array (current_max_rules); - rule_useful = allocate_array(current_max_rules, sizeof(char)); - rule_has_nl = allocate_array(current_max_rules, sizeof(char)); - - current_max_scs = INITIAL_MAX_SCS; - scset = allocate_integer_array (current_max_scs); - scbol = allocate_integer_array (current_max_scs); - scxclu = allocate_array(current_max_scs, sizeof(char)); - sceof = allocate_array(current_max_scs, sizeof(char)); - scname = allocate_char_ptr_array (current_max_scs); - - current_maxccls = INITIAL_MAX_CCLS; - cclmap = allocate_integer_array (current_maxccls); - ccllen = allocate_integer_array (current_maxccls); - cclng = allocate_integer_array (current_maxccls); - ccl_has_nl = allocate_array(current_maxccls, sizeof(char)); - - current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE; - ccltbl = allocate_Character_array (current_max_ccl_tbl_size); - - current_max_dfa_size = INITIAL_MAX_DFA_SIZE; - - current_max_xpairs = INITIAL_MAX_XPAIRS; - nxt = allocate_integer_array (current_max_xpairs); - chk = allocate_integer_array (current_max_xpairs); - - current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS; - tnxt = allocate_integer_array (current_max_template_xpairs); - - current_max_dfas = INITIAL_MAX_DFAS; - base = allocate_integer_array (current_max_dfas); - def = allocate_integer_array (current_max_dfas); - dfasiz = allocate_integer_array (current_max_dfas); - accsiz = allocate_integer_array (current_max_dfas); - dhash = allocate_integer_array (current_max_dfas); - dss = allocate_int_ptr_array (current_max_dfas); - dfaacc = allocate_array(current_max_dfas, + gv->maximum_mns = (gv->ctrl.long_align ? MAXIMUM_MNS_LONG : MAXIMUM_MNS); + gv->current_mns = INITIAL_MNS; + gv->firstst = allocate_integer_array (gv->current_mns); + gv->lastst = allocate_integer_array (gv->current_mns); + gv->finalst = allocate_integer_array (gv->current_mns); + gv->transchar = allocate_integer_array (gv->current_mns); + gv->trans1 = allocate_integer_array (gv->current_mns); + gv->trans2 = allocate_integer_array (gv->current_mns); + gv->accptnum = allocate_integer_array (gv->current_mns); + gv->assoc_rule = allocate_integer_array (gv->current_mns); + gv->state_type = allocate_integer_array (gv->current_mns); + + gv->current_max_rules = INITIAL_MAX_RULES; + gv->rule_type = allocate_integer_array (gv->current_max_rules); + gv->rule_linenum = allocate_integer_array (gv->current_max_rules); + gv->rule_useful = allocate_array(gv->current_max_rules, sizeof(char)); + gv->rule_has_nl = allocate_array(gv->current_max_rules, sizeof(char)); + + gv->current_max_scs = INITIAL_MAX_SCS; + gv->scset = allocate_integer_array (gv->current_max_scs); + gv->scbol = allocate_integer_array (gv->current_max_scs); + gv->scxclu = allocate_array(gv->current_max_scs, sizeof(char)); + gv->sceof = allocate_array(gv->current_max_scs, sizeof(char)); + gv->scname = allocate_char_ptr_array (gv->current_max_scs); + + gv->current_maxccls = INITIAL_MAX_CCLS; + gv->cclmap = allocate_integer_array (gv->current_maxccls); + gv->ccllen = allocate_integer_array (gv->current_maxccls); + gv->cclng = allocate_integer_array (gv->current_maxccls); + gv->ccl_has_nl = allocate_array(gv->current_maxccls, sizeof(char)); + + gv->current_max_ccl_tbl_size = INITIAL_MAX_CCL_TBL_SIZE; + gv->ccltbl = allocate_Character_array (gv->current_max_ccl_tbl_size); + + gv->current_max_dfa_size = INITIAL_MAX_DFA_SIZE; + + gv->current_max_xpairs = INITIAL_MAX_XPAIRS; + gv->nxt = allocate_integer_array (gv->current_max_xpairs); + gv->chk = allocate_integer_array (gv->current_max_xpairs); + + gv->current_max_template_xpairs = INITIAL_MAX_TEMPLATE_XPAIRS; + gv->tnxt = allocate_integer_array (gv->current_max_template_xpairs); + + gv->current_max_dfas = INITIAL_MAX_DFAS; + gv->base = allocate_integer_array (gv->current_max_dfas); + gv->def = allocate_integer_array (gv->current_max_dfas); + gv->dfasiz = allocate_integer_array (gv->current_max_dfas); + gv->accsiz = allocate_integer_array (gv->current_max_dfas); + gv->dhash = allocate_integer_array (gv->current_max_dfas); + gv->dss = allocate_int_ptr_array (gv->current_max_dfas); + gv->dfaacc = allocate_array(gv->current_max_dfas, sizeof(union dfaacc_union)); - nultrans = NULL; + gv->nultrans = NULL; } @@ -1742,13 +1760,13 @@ void usage (void) { FILE *f = stdout; - if (!env.did_outfilename) { - snprintf (outfile_path, sizeof(outfile_path), outfile_template, - ctrl.prefix, suffix()); - env.outfilename = outfile_path; + if (!gv->env.did_outfilename) { + snprintf (gv->outfile_path, sizeof(gv->outfile_path), gv->outfile_template, + gv->ctrl.prefix, suffix()); + gv->env.outfilename = gv->outfile_path; } - fprintf (f, _("Usage: %s [OPTIONS] [FILE]...\n"), program_name); + fprintf (f, _("Usage: %s [OPTIONS] [FILE]...\n"), gv->program_name); fprintf (f, _ ("Generates programs that perform pattern-matching on text.\n" @@ -1806,6 +1824,6 @@ void usage (void) " -?\n" " -h, --help produce this help message\n" " -V, --version report %s version\n"), - backing_name, "flex", outfile_path, "flex"); + gv->backing_name, "flex", gv->outfile_path, "flex"); } diff --git a/src/misc.c b/src/misc.c index 56d2abab6..56c27bf43 100644 --- a/src/misc.c +++ b/src/misc.c @@ -38,24 +38,24 @@ void add_action (const char *new_text) { int len = (int) strlen (new_text); - while (len + action_index >= action_size - 10 /* slop */ ) { + while (len + gv->action_index >= gv->action_size - 10 /* slop */ ) { - if (action_size > INT_MAX / 2) + if (gv->action_size > INT_MAX / 2) /* Increase just a little, to try to avoid overflow * on 16-bit machines. */ - action_size += action_size / 8; + gv->action_size += gv->action_size / 8; else - action_size = action_size * 2; + gv->action_size = gv->action_size * 2; - action_array = - reallocate_character_array (action_array, - action_size); + gv->action_array = + reallocate_character_array (gv->action_array, + gv->action_size); } - strcpy (&action_array[action_index], new_text); + strcpy (&gv->action_array[gv->action_index], new_text); - action_index += len; + gv->action_index += len; } @@ -114,7 +114,7 @@ void check_char (int c) lerr (_("bad character '%s' detected in check_char()"), readable_form (c)); - if (c >= ctrl.csize) + if (c >= gv->ctrl.csize) lerr (_ ("scanner requires -8 flag to use the character %s"), readable_form (c)); @@ -160,17 +160,17 @@ int cclcmp (const void *a, const void *b) void dataend (const char *endit) { /* short circuit any output */ - if (gentables) { + if (gv->gentables) { - if (datapos > 0) + if (gv->datapos > 0) dataflush (); /* add terminator for initialization; { for vi */ if (endit) outn (endit); } - dataline = 0; - datapos = 0; + gv->dataline = 0; + gv->datapos = 0; } @@ -180,19 +180,19 @@ void dataflush (void) { assert (gentables); - if (datapos > 0) + if (gv->datapos > 0) outc ('\n'); - if (++dataline >= NUMDATALINES) { + if (++gv->dataline >= NUMDATALINES) { /* Put out a blank line so that the table is grouped into * large blocks that enable the user to find elements easily. */ outc ('\n'); - dataline = 0; + gv->dataline = 0; } /* Reset the number of characters written on the current line. */ - datapos = 0; + gv->datapos = 0; } @@ -200,7 +200,7 @@ void dataflush (void) void flexerror (const char *msg) { - fprintf (stderr, "%s: %s\n", program_name, msg); + fprintf (stderr, "%s: %s\n", gv->program_name, msg); flexend (1); } @@ -210,7 +210,7 @@ void flexerror (const char *msg) void flexfatal (const char *msg) { fprintf (stderr, _("%s: fatal internal error, %s\n"), - program_name, msg); + gv->program_name, msg); FLEX_EXIT (1); } @@ -250,7 +250,7 @@ void line_directive_out (FILE *output_file, char *path, int linenum) char directive[MAXLINE*2], filename[MAXLINE]; char *s1, *s2, *s3; - if (!ctrl.gen_line_dirs) + if (!gv->ctrl.gen_line_dirs) return; s1 = (path != NULL) ? path : "M4_YY_OUTFILE_NAME"; @@ -294,10 +294,10 @@ void line_directive_out (FILE *output_file, char *path, int linenum) */ void mark_defs1 (void) { - defs1_offset = 0; - action_array[action_index++] = '\0'; - action_offset = prolog_offset = action_index; - action_array[action_index] = '\0'; + gv->defs1_offset = 0; + gv->action_array[gv->action_index++] = '\0'; + gv->action_offset = gv->prolog_offset = gv->action_index; + gv->action_array[gv->action_index] = '\0'; } @@ -306,9 +306,9 @@ void mark_defs1 (void) */ void mark_prolog (void) { - action_array[action_index++] = '\0'; - action_offset = action_index; - action_array[action_index] = '\0'; + gv->action_array[gv->action_index++] = '\0'; + gv->action_offset = gv->action_index; + gv->action_array[gv->action_index] = '\0'; } @@ -319,22 +319,22 @@ void mark_prolog (void) void mk2data (int value) { /* short circuit any output */ - if (!gentables) + if (!gv->gentables) return; - if (datapos >= NUMDATAITEMS) { + if (gv->datapos >= NUMDATAITEMS) { outc (','); dataflush (); } - if (datapos == 0) + if (gv->datapos == 0) /* Indent. */ out (" "); else outc (','); - ++datapos; + ++gv->datapos; out_dec ("%5d", value); } @@ -348,20 +348,20 @@ void mk2data (int value) void mkdata (int value) { /* short circuit any output */ - if (!gentables) + if (!gv->gentables) return; - if (datapos >= NUMDATAITEMS) { + if (gv->datapos >= NUMDATAITEMS) { outc (','); dataflush (); } - if (datapos == 0) + if (gv->datapos == 0) /* Indent. */ out (" "); else outc (','); - ++datapos; + ++gv->datapos; out_dec ("%5d", value); } @@ -517,7 +517,7 @@ void out_m4_define (const char* def, const char* val) char *readable_form (int c) { - static char rform[20]; + //static char rform[20]; if ((c >= 0 && c < 32) || c >= 127) { switch (c) { @@ -536,11 +536,11 @@ char *readable_form (int c) case '\v': return "\\v"; default: - if(env.trace_hex) - snprintf (rform, sizeof(rform), "\\x%.2x", (unsigned int) c); + if(gv->env.trace_hex) + snprintf (gv->rform, sizeof(gv->rform), "\\x%.2x", (unsigned int) c); else - snprintf (rform, sizeof(rform), "\\%.3o", (unsigned int) c); - return rform; + snprintf (gv->rform, sizeof(gv->rform), "\\%.3o", (unsigned int) c); + return gv->rform; } } @@ -548,10 +548,10 @@ char *readable_form (int c) return "' '"; else { - rform[0] = (char) c; - rform[1] = '\0'; + gv->rform[0] = (char) c; + gv->rform[1] = '\0'; - return rform; + return gv->rform; } } @@ -601,21 +601,21 @@ void transition_struct_out (int element_v, int element_n) { /* short circuit any output */ - if (!gentables) + if (!gv->gentables) return; out_dec2 ("M4_HOOK_TABLE_OPENER[[%4d]],[[%4d]]M4_HOOK_TABLE_CONTINUE", element_v, element_n); outc ('\n'); - datapos += TRANS_STRUCT_PRINT_LENGTH; + gv->datapos += TRANS_STRUCT_PRINT_LENGTH; - if (datapos >= 79 - TRANS_STRUCT_PRINT_LENGTH) { + if (gv->datapos >= 79 - TRANS_STRUCT_PRINT_LENGTH) { outc ('\n'); - if (++dataline % 10 == 0) + if (++gv->dataline % 10 == 0) outc ('\n'); - datapos = 0; + gv->datapos = 0; } } diff --git a/src/nfa.c b/src/nfa.c index 8da347457..9c3e327c2 100644 --- a/src/nfa.c +++ b/src/nfa.c @@ -53,13 +53,13 @@ void add_accept (int mach, int accepting_number) * too soon. */ - if (transchar[finalst[mach]] == SYM_EPSILON) - accptnum[finalst[mach]] = accepting_number; + if (gv->transchar[gv->finalst[mach]] == SYM_EPSILON) + gv->accptnum[gv->finalst[mach]] = accepting_number; else { int astate = mkstate (SYM_EPSILON); - accptnum[astate] = accepting_number; + gv->accptnum[astate] = accepting_number; (void) link_machines (mach, astate); } } @@ -107,13 +107,13 @@ void dumpnfa (int state1) */ /* for ( ns = firstst[state1]; ns <= lastst[state1]; ++ns ) */ - for (ns = 1; ns <= lastnfa; ++ns) { + for (ns = 1; ns <= gv->lastnfa; ++ns) { fprintf (stderr, _("state # %4d\t"), ns); - sym = transchar[ns]; - tsp1 = trans1[ns]; - tsp2 = trans2[ns]; - anum = accptnum[ns]; + sym = gv->transchar[ns]; + tsp1 = gv->trans1[ns]; + tsp2 = gv->trans2[ns]; + anum = gv->accptnum[ns]; fprintf (stderr, "%3d: %4d, %4d", sym, tsp1, tsp2); @@ -148,21 +148,21 @@ int dupmachine (int mach) { int i, init, state_offset; int state = 0; - int last = lastst[mach]; + int last = gv->lastst[mach]; - for (i = firstst[mach]; i <= last; ++i) { - state = mkstate (transchar[i]); + for (i = gv->firstst[mach]; i <= last; ++i) { + state = mkstate (gv->transchar[i]); - if (trans1[i] != NO_TRANSITION) { - mkxtion (finalst[state], trans1[i] + state - i); + if (gv->trans1[i] != NO_TRANSITION) { + mkxtion (gv->finalst[state], gv->trans1[i] + state - i); - if (transchar[i] == SYM_EPSILON && - trans2[i] != NO_TRANSITION) - mkxtion (finalst[state], - trans2[i] + state - i); + if (gv->transchar[i] == SYM_EPSILON && + gv->trans2[i] != NO_TRANSITION) + mkxtion (gv->finalst[state], + gv->trans2[i] + state - i); } - accptnum[state] = accptnum[i]; + gv->accptnum[state] = gv->accptnum[i]; } if (state == 0) @@ -171,9 +171,9 @@ int dupmachine (int mach) state_offset = state - i + 1; init = mach + state_offset; - firstst[init] = firstst[mach] + state_offset; - finalst[init] = finalst[mach] + state_offset; - lastst[init] = lastst[mach] + state_offset; + gv->firstst[init] = gv->firstst[mach] + state_offset; + gv->finalst[init] = gv->finalst[mach] + state_offset; + gv->lastst[init] = gv->lastst[mach] + state_offset; return init; } @@ -196,49 +196,49 @@ void finish_rule (int mach, bool variable_trail_rule, int headcnt, int trailc { char action_text[MAXLINE]; - add_accept (mach, num_rules); + add_accept (mach, gv->num_rules); /* We did this in new_rule(), but it often gets the wrong * number because we do it before we start parsing the current rule. */ - rule_linenum[num_rules] = linenum; + gv->rule_linenum[gv->num_rules] = gv->linenum; /* If this is a continued action, then the line-number has already * been updated, giving us the wrong number. */ - if (continued_action) - --rule_linenum[num_rules]; + if (gv->continued_action) + --gv->rule_linenum[gv->num_rules]; /* If the previous rule was continued action, then we inherit the * previous newline flag, possibly overriding the current one. */ - if (pcont_act && rule_has_nl[num_rules - 1]) - rule_has_nl[num_rules] = true; + if (pcont_act && gv->rule_has_nl[gv->num_rules - 1]) + gv->rule_has_nl[gv->num_rules] = true; - snprintf (action_text, sizeof(action_text), "M4_HOOK_NORMAL_STATE_CASE_ARM(%d)\n", num_rules); + snprintf (action_text, sizeof(action_text), "M4_HOOK_NORMAL_STATE_CASE_ARM(%d)\n", gv->num_rules); add_action (action_text); - if (rule_has_nl[num_rules]) { + if (gv->rule_has_nl[gv->num_rules]) { snprintf (action_text, sizeof(action_text), "M4_HOOK_COMMENT_OPEN rule %d can match eol M4_HOOK_COMMENT_CLOSE\n", - num_rules); + gv->num_rules); add_action (action_text); } if (variable_trail_rule) { - rule_type[num_rules] = RULE_VARIABLE; + gv->rule_type[gv->num_rules] = RULE_VARIABLE; - if (env.performance_hint > 0) + if (gv->env.performance_hint > 0) fprintf (stderr, _ ("Variable trailing context rule at line %d\n"), - rule_linenum[num_rules]); + gv->rule_linenum[gv->num_rules]); - variable_trailing_context_rules = true; + gv->variable_trailing_context_rules = true; } else { - rule_type[num_rules] = RULE_NORMAL; + gv->rule_type[gv->num_rules] = RULE_NORMAL; if (headcnt > 0 || trailcnt > 0) { /* Do trailing context magic to not match the trailing @@ -247,7 +247,7 @@ void finish_rule (int mach, bool variable_trail_rule, int headcnt, int trailc add_action ("M4_HOOK_RELEASE_YYTEXT\n"); if (headcnt > 0) { - if (rule_has_nl[num_rules]) { + if (gv->rule_has_nl[gv->num_rules]) { snprintf (action_text, sizeof(action_text), "M4_HOOK_LINE_FORWARD(%d)\n", headcnt); add_action (action_text); @@ -258,7 +258,7 @@ void finish_rule (int mach, bool variable_trail_rule, int headcnt, int trailc } else { - if (rule_has_nl[num_rules]) { + if (gv->rule_has_nl[gv->num_rules]) { snprintf (action_text, sizeof(action_text), "M4_HOOK_LINE_REWIND(%d)\n", trailcnt); add_action (action_text); @@ -279,10 +279,10 @@ void finish_rule (int mach, bool variable_trail_rule, int headcnt, int trailc * to do any user action. But don't do it for continued actions, * as that'll result in multiple rule-setup calls. */ - if (!continued_action) + if (!gv->continued_action) add_action ("M4_HOOK_SET_RULE_SETUP\n"); - line_directive_out(NULL, infilename, linenum); + line_directive_out(NULL, gv->infilename, gv->linenum); add_action("[["); } @@ -312,10 +312,10 @@ int link_machines (int first, int last) return first; else { - mkxtion (finalst[first], last); - finalst[first] = finalst[last]; - lastst[first] = MAX (lastst[first], lastst[last]); - firstst[first] = MIN (firstst[first], firstst[last]); + mkxtion (gv->finalst[first], last); + gv->finalst[first] = gv->finalst[last]; + gv->lastst[first] = MAX (gv->lastst[first], gv->lastst[last]); + gv->firstst[first] = MIN (gv->firstst[first], gv->firstst[last]); return first; } @@ -331,20 +331,20 @@ int link_machines (int first, int last) void mark_beginning_as_normal (int mach) { - switch (state_type[mach]) { + switch (gv->state_type[mach]) { case STATE_NORMAL: /* Oh, we've already visited here. */ return; case STATE_TRAILING_CONTEXT: - state_type[mach] = STATE_NORMAL; + gv->state_type[mach] = STATE_NORMAL; - if (transchar[mach] == SYM_EPSILON) { - if (trans1[mach] != NO_TRANSITION) - mark_beginning_as_normal (trans1[mach]); + if (gv->transchar[mach] == SYM_EPSILON) { + if (gv->trans1[mach] != NO_TRANSITION) + mark_beginning_as_normal (gv->trans1[mach]); - if (trans2[mach] != NO_TRANSITION) - mark_beginning_as_normal (trans2[mach]); + if (gv->trans2[mach] != NO_TRANSITION) + mark_beginning_as_normal (gv->trans2[mach]); } break; @@ -421,7 +421,7 @@ int mkopt (int mach) { int eps; - if (!SUPER_FREE_EPSILON (finalst[mach])) { + if (!SUPER_FREE_EPSILON (gv->finalst[mach])) { eps = mkstate (SYM_EPSILON); mach = link_machines (mach, eps); } @@ -433,7 +433,7 @@ int mkopt (int mach) eps = mkstate (SYM_EPSILON); mach = link_machines (eps, mach); - mkxtion (mach, finalst[mach]); + mkxtion (mach, gv->finalst[mach]); return mach; } @@ -473,31 +473,31 @@ int mkor (int first, int second) mkxtion (first, second); - if (SUPER_FREE_EPSILON (finalst[first]) && - accptnum[finalst[first]] == NIL) { - orend = finalst[first]; - mkxtion (finalst[second], orend); + if (SUPER_FREE_EPSILON (gv->finalst[first]) && + gv->accptnum[gv->finalst[first]] == NIL) { + orend = gv->finalst[first]; + mkxtion (gv->finalst[second], orend); } - else if (SUPER_FREE_EPSILON (finalst[second]) && - accptnum[finalst[second]] == NIL) { - orend = finalst[second]; - mkxtion (finalst[first], orend); + else if (SUPER_FREE_EPSILON (gv->finalst[second]) && + gv->accptnum[gv->finalst[second]] == NIL) { + orend = gv->finalst[second]; + mkxtion (gv->finalst[first], orend); } else { eps = mkstate (SYM_EPSILON); first = link_machines (first, eps); - orend = finalst[first]; + orend = gv->finalst[first]; - mkxtion (finalst[second], orend); + mkxtion (gv->finalst[second], orend); } } - firstst[first] = MIN(firstst[first], firstst[second]); + gv->firstst[first] = MIN(gv->firstst[first], gv->firstst[second]); - finalst[first] = orend; + gv->finalst[first] = orend; return first; } @@ -514,8 +514,8 @@ int mkposcl (int state) { int eps; - if (SUPER_FREE_EPSILON (finalst[state])) { - mkxtion (finalst[state], state); + if (SUPER_FREE_EPSILON (gv->finalst[state])) { + mkxtion (gv->finalst[state], state); return state; } @@ -587,38 +587,38 @@ int mkrep (int mach, int lb, int ub) int mkstate (int sym) { - if (++lastnfa >= current_mns) { - if ((current_mns += MNS_INCREMENT) >= maximum_mns) + if (++gv->lastnfa >= gv->current_mns) { + if ((gv->current_mns += MNS_INCREMENT) >= gv->maximum_mns) lerr(_ ("input rules are too complicated (>= %d NFA states)"), -current_mns); - - ++num_reallocs; - - firstst = reallocate_integer_array (firstst, current_mns); - lastst = reallocate_integer_array (lastst, current_mns); - finalst = reallocate_integer_array (finalst, current_mns); - transchar = - reallocate_integer_array (transchar, current_mns); - trans1 = reallocate_integer_array (trans1, current_mns); - trans2 = reallocate_integer_array (trans2, current_mns); - accptnum = - reallocate_integer_array (accptnum, current_mns); - assoc_rule = - reallocate_integer_array (assoc_rule, current_mns); - state_type = - reallocate_integer_array (state_type, current_mns); +gv->current_mns); + + ++gv->num_reallocs; + + gv->firstst = reallocate_integer_array (gv->firstst, gv->current_mns); + gv->lastst = reallocate_integer_array (gv->lastst, gv->current_mns); + gv->finalst = reallocate_integer_array (gv->finalst, gv->current_mns); + gv->transchar = + reallocate_integer_array (gv->transchar, gv->current_mns); + gv->trans1 = reallocate_integer_array (gv->trans1, gv->current_mns); + gv->trans2 = reallocate_integer_array (gv->trans2, gv->current_mns); + gv->accptnum = + reallocate_integer_array (gv->accptnum, gv->current_mns); + gv->assoc_rule = + reallocate_integer_array (gv->assoc_rule, gv->current_mns); + gv->state_type = + reallocate_integer_array (gv->state_type, gv->current_mns); } - firstst[lastnfa] = lastnfa; - finalst[lastnfa] = lastnfa; - lastst[lastnfa] = lastnfa; - transchar[lastnfa] = sym; - trans1[lastnfa] = NO_TRANSITION; - trans2[lastnfa] = NO_TRANSITION; - accptnum[lastnfa] = NIL; - assoc_rule[lastnfa] = num_rules; - state_type[lastnfa] = current_state_type; + gv->firstst[gv->lastnfa] = gv->lastnfa; + gv->finalst[gv->lastnfa] = gv->lastnfa; + gv->lastst[gv->lastnfa] = gv->lastnfa; + gv->transchar[gv->lastnfa] = sym; + gv->trans1[gv->lastnfa] = NO_TRANSITION; + gv->trans2[gv->lastnfa] = NO_TRANSITION; + gv->accptnum[gv->lastnfa] = NIL; + gv->assoc_rule[gv->lastnfa] = gv->num_rules; + gv->state_type[gv->lastnfa] = gv->current_state_type; /* Fix up equivalence classes base on this transition. Note that any * character which has its own transition gets its own equivalence @@ -637,17 +637,17 @@ current_mns); } else if (sym == SYM_EPSILON) - ++numeps; + ++gv->numeps; else { check_char (sym); - if (ctrl.useecs) + if (gv->ctrl.useecs) /* Map NUL's to csize. */ - mkechar (sym ? sym : ctrl.csize, nextecm, ecgroup); + mkechar (sym ? sym : gv->ctrl.csize, gv->nextecm, gv->ecgroup); } - return lastnfa; + return gv->lastnfa; } @@ -663,16 +663,16 @@ current_mns); void mkxtion (int statefrom, int stateto) { - if (trans1[statefrom] == NO_TRANSITION) - trans1[statefrom] = stateto; + if (gv->trans1[statefrom] == NO_TRANSITION) + gv->trans1[statefrom] = stateto; - else if ((transchar[statefrom] != SYM_EPSILON) || - (trans2[statefrom] != NO_TRANSITION)) + else if ((gv->transchar[statefrom] != SYM_EPSILON) || + (gv->trans2[statefrom] != NO_TRANSITION)) flexfatal (_("found too many transitions in mkxtion()")); else { /* second out-transition for an epsilon state */ - ++eps2; - trans2[statefrom] = stateto; + ++gv->eps2; + gv->trans2[statefrom] = stateto; } } @@ -680,23 +680,23 @@ void mkxtion (int statefrom, int stateto) void new_rule (void) { - if (++num_rules >= current_max_rules) { - ++num_reallocs; - current_max_rules += MAX_RULES_INCREMENT; - rule_type = reallocate_integer_array (rule_type, - current_max_rules); - rule_linenum = reallocate_integer_array (rule_linenum, - current_max_rules); - rule_useful = reallocate_array(rule_useful, - current_max_rules, sizeof(char)); - rule_has_nl = reallocate_array(rule_has_nl, - current_max_rules, sizeof(char)); + if (++gv->num_rules >= gv->current_max_rules) { + ++gv->num_reallocs; + gv->current_max_rules += MAX_RULES_INCREMENT; + gv->rule_type = reallocate_integer_array (gv->rule_type, + gv->current_max_rules); + gv->rule_linenum = reallocate_integer_array (gv->rule_linenum, + gv->current_max_rules); + gv->rule_useful = reallocate_array(gv->rule_useful, + gv->current_max_rules, sizeof(char)); + gv->rule_has_nl = reallocate_array(gv->rule_has_nl, + gv->current_max_rules, sizeof(char)); } - if (num_rules > MAX_RULE) + if (gv->num_rules > MAX_RULE) lerr (_("too many rules (> %d)!"), MAX_RULE); - rule_linenum[num_rules] = linenum; - rule_useful[num_rules] = false; - rule_has_nl[num_rules] = false; + gv->rule_linenum[gv->num_rules] = gv->linenum; + gv->rule_useful[gv->num_rules] = false; + gv->rule_has_nl[gv->num_rules] = false; } diff --git a/src/options.c b/src/options.c index 8b7fd8a1b..39289f253 100644 --- a/src/options.c +++ b/src/options.c @@ -40,7 +40,7 @@ /* The command-line options, passed to scanopt_init() */ -optspec_t flexopts[] = { +const optspec_t flexopts[] = { {"-7", OPT_7BIT, 0} , diff --git a/src/options.h b/src/options.h index a2d3786aa..d2f9e61e8 100644 --- a/src/options.h +++ b/src/options.h @@ -35,7 +35,7 @@ #define OPTIONS_H #include "scanopt.h" -extern optspec_t flexopts[]; +extern const optspec_t flexopts[]; enum flexopt_flag_t { /* Use positive integers only, since they are return codes for scanopt. diff --git a/src/parse.y b/src/parse.y index 80e7f0977..109cae124 100644 --- a/src/parse.y +++ b/src/parse.y @@ -67,17 +67,17 @@ #include "flexdef.h" #include "tables.h" -int pat, scnum, eps, headcnt, trailcnt, lastchar, i, rulelen; -static int currccl; -bool trlcontxt; -static bool sc_is_exclusive, cclsorted, varlength, variable_trail_rule; +//int pat, scnum, eps, headcnt, trailcnt, lastchar, i, rulelen; +//static int currccl; +//bool trlcontxt; +//static bool sc_is_exclusive, cclsorted, varlength, variable_trail_rule; -int *scon_stk; -int scon_stk_ptr; +//int *scon_stk; +//int scon_stk_ptr; -static int madeany = false; /* whether we've made the '.' character class */ -static int ccldot, cclany; -int previous_continued_action; /* whether the previous rule's action was '|' */ +//static int madeany = false; /* whether we've made the '.' character class */ +//static int ccldot, cclany; +//int previous_continued_action; /* whether the previous rule's action was '|' */ #define format_warn3(fmt, a1, a2) \ do{ \ @@ -90,18 +90,18 @@ int previous_continued_action; /* whether the previous rule's action was '|' */ #define CCL_EXPR(func) \ do{ \ int c; \ - for ( c = 0; c < ctrl.csize; ++c ) \ + for ( c = 0; c < gv->ctrl.csize; ++c ) \ if ( isascii(c) && func(c) ) \ - ccladd( currccl, c ); \ + ccladd( gv->currccl, c ); \ }while(0) /* negated class */ #define CCL_NEG_EXPR(func) \ do{ \ int c; \ - for ( c = 0; c < ctrl.csize; ++c ) \ + for ( c = 0; c < gv->ctrl.csize; ++c ) \ if ( !func(c) ) \ - ccladd( currccl, c ); \ + ccladd( gv->currccl, c ); \ }while(0) /* While POSIX defines isblank(), it's not ANSI C. */ @@ -122,24 +122,24 @@ goal : initlex sect1 sect1end sect2 initforrule { /* add default rule */ int def_rule; - pat = cclinit(); - cclnegate( pat ); + gv->pat = cclinit(); + cclnegate( gv->pat ); - def_rule = mkstate( -pat ); + def_rule = mkstate( -gv->pat ); /* Remember the number of the default rule so we * don't generate "can't match" warnings for it. */ - default_rule = num_rules; + gv->default_rule = gv->num_rules; finish_rule( def_rule, false, 0, 0, 0); - for ( i = 1; i <= lastsc; ++i ) - scset[i] = mkbranch( scset[i], def_rule ); + for ( gv->i_parse = 1; gv->i_parse <= gv->lastsc; ++gv->i_parse ) + gv->scset[gv->i_parse] = mkbranch( gv->scset[gv->i_parse], def_rule ); add_action("]]"); - if ( ctrl.spprdflt ) + if ( gv->ctrl.spprdflt ) add_action( "M4_HOOK_FATAL_ERROR(\"flex scanner jammed\")"); else { @@ -168,23 +168,23 @@ sect1 : sect1 startconddecl namelist1 sect1end : SECTEND { check_options(); - scon_stk = allocate_integer_array( lastsc + 1 ); - scon_stk_ptr = 0; + gv->scon_stk = allocate_integer_array( gv->lastsc + 1 ); + gv->scon_stk_ptr = 0; } ; startconddecl : SCDECL - { sc_is_exclusive = false; } + { gv->sc_is_exclusive = false; } | XSCDECL - { sc_is_exclusive = true; } + { gv->sc_is_exclusive = true; } ; namelist1 : namelist1 NAME - { scinstal( nmstr, sc_is_exclusive ); } + { scinstal( gv->nmstr, gv->sc_is_exclusive ); } | NAME - { scinstal( nmstr, sc_is_exclusive ); } + { scinstal( gv->nmstr, gv->sc_is_exclusive ); } | error { synerr( _("bad start condition list") ); } @@ -199,54 +199,54 @@ optionlist : optionlist option option : TOK_OUTFILE '=' NAME { - env.outfilename = xstrdup(nmstr); - env.did_outfilename = 1; + gv->env.outfilename = xstrdup(gv->nmstr); + gv->env.did_outfilename = 1; } | TOK_EXTRA_TYPE '=' NAME - { extra_type = xstrdup(nmstr); } + { gv->extra_type = xstrdup(gv->nmstr); } | TOK_PREFIX '=' NAME - { ctrl.prefix = xstrdup(nmstr); - if (strchr(ctrl.prefix, '[') || strchr(ctrl.prefix, ']')) + { gv->ctrl.prefix = xstrdup(gv->nmstr); + if (strchr(gv->ctrl.prefix, '[') || strchr(gv->ctrl.prefix, ']')) flexerror(_("Prefix must not contain [ or ]")); } | TOK_YYCLASS '=' NAME - { ctrl.yyclass = xstrdup(nmstr); } + { gv->ctrl.yyclass = xstrdup(gv->nmstr); } | TOK_HEADER_FILE '=' NAME - { env.headerfilename = xstrdup(nmstr); } + { gv->env.headerfilename = xstrdup(gv->nmstr); } | TOK_YYLMAX '=' TOK_NUMERIC - { ctrl.yylmax = nmval; } + { gv->ctrl.yylmax = gv->nmval; } | TOK_YYDECL '=' NAME - { ctrl.yydecl = xstrdup(nmstr); } + { gv->ctrl.yydecl = xstrdup(gv->nmstr); } | TOK_PREACTION '=' NAME - { ctrl.preaction = xstrdup(nmstr); } + { gv->ctrl.preaction = xstrdup(gv->nmstr); } | TOK_POSTACTION '=' NAME - { ctrl.postaction = xstrdup(nmstr); } + { gv->ctrl.postaction = xstrdup(gv->nmstr); } | TOK_BUFSIZE '=' TOK_NUMERIC - { ctrl.bufsize = nmval; } + { gv->ctrl.bufsize = gv->nmval; } | TOK_EMIT '=' NAME - { ctrl.emit = xstrdup(nmstr); backend_by_name(ctrl.emit); } + { gv->ctrl.emit = xstrdup(gv->nmstr); backend_by_name(gv->ctrl.emit); } | TOK_USERINIT '=' NAME - { ctrl.userinit = xstrdup(nmstr); } + { gv->ctrl.userinit = xstrdup(gv->nmstr); } | TOK_YYTERMINATE '=' NAME - { ctrl.yyterminate = xstrdup(nmstr); } + { gv->ctrl.yyterminate = xstrdup(gv->nmstr); } | TOK_TABLES_FILE '=' NAME - { tablesext = true; tablesfilename = xstrdup(nmstr); } + { gv->tablesext = true; gv->tablesfilename = xstrdup(gv->nmstr); } ; sect2 : sect2 scon initforrule flexrule '\n' - { scon_stk_ptr = $2; } + { gv->scon_stk_ptr = $2; } | sect2 scon '{' sect2 '}' - { scon_stk_ptr = $2; } + { gv->scon_stk_ptr = $2; } | ; initforrule : { /* Initialize for a parse of one rule. */ - trlcontxt = variable_trail_rule = varlength = false; - trailcnt = headcnt = rulelen = 0; - current_state_type = STATE_NORMAL; - previous_continued_action = continued_action; - in_rule = true; + gv->trlcontxt = gv->variable_trail_rule = gv->varlength = false; + gv->trailcnt = gv->headcnt = gv->rulelen = 0; + gv->current_state_type = STATE_NORMAL; + gv->previous_continued_action = gv->continued_action; + gv->in_rule = true; new_rule(); } @@ -254,16 +254,16 @@ initforrule : flexrule : '^' rule { - pat = $2; - finish_rule( pat, variable_trail_rule, - headcnt, trailcnt , previous_continued_action); + gv->pat = $2; + finish_rule( gv->pat, gv->variable_trail_rule, + gv->headcnt, gv->trailcnt , gv->previous_continued_action); - if ( scon_stk_ptr > 0 ) + if ( gv->scon_stk_ptr > 0 ) { - for ( i = 1; i <= scon_stk_ptr; ++i ) - scbol[scon_stk[i]] = - mkbranch( scbol[scon_stk[i]], - pat ); + for ( gv->i_parse = 1; gv->i_parse <= gv->scon_stk_ptr; ++gv->i_parse ) + gv->scbol[gv->scon_stk[gv->i_parse]] = + mkbranch( gv->scbol[gv->scon_stk[gv->i_parse]], + gv->pat ); } else @@ -272,17 +272,17 @@ flexrule : '^' rule * including the default (0) start condition. */ - for ( i = 1; i <= lastsc; ++i ) - if ( ! scxclu[i] ) - scbol[i] = mkbranch( scbol[i], - pat ); + for ( gv->i_parse = 1; gv->i_parse <= gv->lastsc; ++gv->i_parse ) + if ( ! gv->scxclu[gv->i_parse] ) + gv->scbol[gv->i_parse] = mkbranch( gv->scbol[gv->i_parse], + gv->pat ); } - if ( ! bol_needed ) + if ( ! gv->bol_needed ) { - bol_needed = true; + gv->bol_needed = true; - if ( env.performance_hint > 1 ) + if ( gv->env.performance_hint > 1 ) pinpoint_message( "'^' operator results in sub-optimal performance" ); } @@ -290,31 +290,31 @@ flexrule : '^' rule | rule { - pat = $1; - finish_rule( pat, variable_trail_rule, - headcnt, trailcnt , previous_continued_action); + gv->pat = $1; + finish_rule( gv->pat, gv->variable_trail_rule, + gv->headcnt, gv->trailcnt , gv->previous_continued_action); - if ( scon_stk_ptr > 0 ) + if ( gv->scon_stk_ptr > 0 ) { - for ( i = 1; i <= scon_stk_ptr; ++i ) - scset[scon_stk[i]] = - mkbranch( scset[scon_stk[i]], - pat ); + for ( gv->i_parse = 1; gv->i_parse <= gv->scon_stk_ptr; ++gv->i_parse ) + gv->scset[gv->scon_stk[gv->i_parse]] = + mkbranch( gv->scset[gv->scon_stk[gv->i_parse]], + gv->pat ); } else { - for ( i = 1; i <= lastsc; ++i ) - if ( ! scxclu[i] ) - scset[i] = - mkbranch( scset[i], - pat ); + for ( gv->i_parse = 1; gv->i_parse <= gv->lastsc; ++gv->i_parse ) + if ( ! gv->scxclu[gv->i_parse] ) + gv->scset[gv->i_parse] = + mkbranch( gv->scset[gv->i_parse], + gv->pat ); } } | EOF_OP { - if ( scon_stk_ptr > 0 ) + if ( gv->scon_stk_ptr > 0 ) build_eof_action(); else @@ -322,11 +322,11 @@ flexrule : '^' rule /* This EOF applies to all start conditions * which don't already have EOF actions. */ - for ( i = 1; i <= lastsc; ++i ) - if ( ! sceof[i] ) - scon_stk[++scon_stk_ptr] = i; + for ( gv->i_parse = 1; gv->i_parse <= gv->lastsc; ++gv->i_parse ) + if ( ! gv->sceof[gv->i_parse] ) + gv->scon_stk[++gv->scon_stk_ptr] = gv->i_parse; - if ( scon_stk_ptr == 0 ) + if ( gv->scon_stk_ptr == 0 ) lwarn( "all start conditions already have <> rules" ); @@ -340,7 +340,7 @@ flexrule : '^' rule ; scon_stk_ptr : - { $$ = scon_stk_ptr; } + { $$ = gv->scon_stk_ptr; } ; scon : '<' scon_stk_ptr namelist2 '>' @@ -348,23 +348,23 @@ scon : '<' scon_stk_ptr namelist2 '>' | '<' '*' '>' { - $$ = scon_stk_ptr; + $$ = gv->scon_stk_ptr; - for ( i = 1; i <= lastsc; ++i ) + for ( gv->i_parse = 1; gv->i_parse <= gv->lastsc; ++gv->i_parse ) { int j; - for ( j = 1; j <= scon_stk_ptr; ++j ) - if ( scon_stk[j] == i ) + for ( j = 1; j <= gv->scon_stk_ptr; ++j ) + if ( gv->scon_stk[j] == gv->i_parse ) break; - if ( j > scon_stk_ptr ) - scon_stk[++scon_stk_ptr] = i; + if ( j > gv->scon_stk_ptr ) + gv->scon_stk[++gv->scon_stk_ptr] = gv->i_parse; } } | - { $$ = scon_stk_ptr; } + { $$ = gv->scon_stk_ptr; } ; namelist2 : namelist2 ',' sconname @@ -377,30 +377,30 @@ namelist2 : namelist2 ',' sconname sconname : NAME { - if ( (scnum = sclookup( nmstr )) == 0 ) + if ( (gv->scnum = sclookup( gv->nmstr )) == 0 ) format_pinpoint_message( "undeclared start condition %s", - nmstr ); + gv->nmstr ); else { - for ( i = 1; i <= scon_stk_ptr; ++i ) - if ( scon_stk[i] == scnum ) + for ( gv->i_parse = 1; gv->i_parse <= gv->scon_stk_ptr; ++gv->i_parse ) + if ( gv->scon_stk[gv->i_parse] == gv->scnum ) { format_warn( "<%s> specified twice", - scname[scnum] ); + gv->scname[gv->scnum] ); break; } - if ( i > scon_stk_ptr ) - scon_stk[++scon_stk_ptr] = scnum; + if ( gv->i_parse > gv->scon_stk_ptr ) + gv->scon_stk[++gv->scon_stk_ptr] = gv->scnum; } } ; rule : re2 re { - if ( transchar[lastst[$2]] != SYM_EPSILON ) + if ( gv->transchar[gv->lastst[$2]] != SYM_EPSILON ) /* Provide final transition \now/ so it * will be marked as a trailing context * state. @@ -409,9 +409,9 @@ rule : re2 re mkstate( SYM_EPSILON ) ); mark_beginning_as_normal( $2 ); - current_state_type = STATE_NORMAL; + gv->current_state_type = STATE_NORMAL; - if ( previous_continued_action ) + if ( gv->previous_continued_action ) { /* We need to treat this as variable trailing * context so that the backup does not happen @@ -421,17 +421,17 @@ rule : re2 re * one's action will *also* do the backup, * erroneously. */ - if ( ! varlength || headcnt != 0 ) + if ( ! gv->varlength || gv->headcnt != 0 ) lwarn( "trailing context made variable due to preceding '|' action" ); /* Mark as variable. */ - varlength = true; - headcnt = 0; + gv->varlength = true; + gv->headcnt = 0; } - if ( ctrl.lex_compat || (varlength && headcnt == 0) ) + if ( gv->ctrl.lex_compat || (gv->varlength && gv->headcnt == 0) ) { /* variable trailing context rule */ /* Mark the first part of the rule as the * accepting "head" part of a trailing @@ -444,12 +444,12 @@ rule : re2 re * a new state ... */ add_accept( $1, - num_rules | YY_TRAILING_HEAD_MASK ); - variable_trail_rule = true; + gv->num_rules | YY_TRAILING_HEAD_MASK ); + gv->variable_trail_rule = true; } else - trailcnt = rulelen; + gv->trailcnt = gv->rulelen; $$ = link_machines( $1, $2 ); } @@ -459,20 +459,20 @@ rule : re2 re | re '$' { - headcnt = 0; - trailcnt = 1; - rulelen = 1; - varlength = false; + gv->headcnt = 0; + gv->trailcnt = 1; + gv->rulelen = 1; + gv->varlength = false; - current_state_type = STATE_TRAILING_CONTEXT; + gv->current_state_type = STATE_TRAILING_CONTEXT; - if ( trlcontxt ) + if ( gv->trlcontxt ) { synerr( _("trailing context used twice") ); $$ = mkstate( SYM_EPSILON ); } - else if ( previous_continued_action ) + else if ( gv->previous_continued_action ) { /* See the comment in the rule for "re2 re" * above. @@ -480,39 +480,39 @@ rule : re2 re lwarn( "trailing context made variable due to preceding '|' action" ); - varlength = true; + gv->varlength = true; } - if ( ctrl.lex_compat || varlength ) + if ( gv->ctrl.lex_compat || gv->varlength ) { /* Again, see the comment in the rule for * "re2 re" above. */ add_accept( $1, - num_rules | YY_TRAILING_HEAD_MASK ); - variable_trail_rule = true; + gv->num_rules | YY_TRAILING_HEAD_MASK ); + gv->variable_trail_rule = true; } - trlcontxt = true; + gv->trlcontxt = true; - eps = mkstate( SYM_EPSILON ); + gv->eps = mkstate( SYM_EPSILON ); $$ = link_machines( $1, - link_machines( eps, mkstate( '\n' ) ) ); + link_machines( gv->eps, mkstate( '\n' ) ) ); } | re { $$ = $1; - if ( trlcontxt ) + if ( gv->trlcontxt ) { - if ( ctrl.lex_compat || (varlength && headcnt == 0) ) + if ( gv->ctrl.lex_compat || (gv->varlength && gv->headcnt == 0) ) /* Both head and trail are * variable-length. */ - variable_trail_rule = true; + gv->variable_trail_rule = true; else - trailcnt = rulelen; + gv->trailcnt = gv->rulelen; } } ; @@ -520,7 +520,7 @@ rule : re2 re re : re '|' series { - varlength = true; + gv->varlength = true; $$ = mkor( $1, $3 ); } @@ -536,22 +536,22 @@ re2 : re '/' * series is parsed. */ - if ( trlcontxt ) + if ( gv->trlcontxt ) synerr( _("trailing context used twice") ); else - trlcontxt = true; + gv->trlcontxt = true; - if ( varlength ) + if ( gv->varlength ) /* We hope the trailing context is * fixed-length. */ - varlength = false; + gv->varlength = false; else - headcnt = rulelen; + gv->headcnt = gv->rulelen; - rulelen = 0; + gv->rulelen = 0; - current_state_type = STATE_TRAILING_CONTEXT; + gv->current_state_type = STATE_TRAILING_CONTEXT; $$ = $1; } ; @@ -569,7 +569,7 @@ series : series singleton | series BEGIN_REPEAT_POSIX NUMBER ',' NUMBER END_REPEAT_POSIX { - varlength = true; + gv->varlength = true; if ( $3 > $5 || $3 < 0 ) { @@ -597,7 +597,7 @@ series : series singleton | series BEGIN_REPEAT_POSIX NUMBER ',' END_REPEAT_POSIX { - varlength = true; + gv->varlength = true; if ( $3 <= 0 ) { @@ -615,7 +615,7 @@ series : series singleton * in which case we have no idea what its length * is, so we punt here. */ - varlength = true; + gv->varlength = true; if ( $3 <= 0 ) { @@ -633,26 +633,26 @@ series : series singleton singleton : singleton '*' { - varlength = true; + gv->varlength = true; $$ = mkclos( $1 ); } | singleton '+' { - varlength = true; + gv->varlength = true; $$ = mkposcl( $1 ); } | singleton '?' { - varlength = true; + gv->varlength = true; $$ = mkopt( $1 ); } | singleton BEGIN_REPEAT_FLEX NUMBER ',' NUMBER END_REPEAT_FLEX { - varlength = true; + gv->varlength = true; if ( $3 > $5 || $3 < 0 ) { @@ -680,7 +680,7 @@ singleton : singleton '*' | singleton BEGIN_REPEAT_FLEX NUMBER ',' END_REPEAT_FLEX { - varlength = true; + gv->varlength = true; if ( $3 <= 0 ) { @@ -698,7 +698,7 @@ singleton : singleton '*' * in which case we have no idea what its length * is, so we punt here. */ - varlength = true; + gv->varlength = true; if ( $3 <= 0 ) { @@ -713,62 +713,62 @@ singleton : singleton '*' | '.' { - if ( ! madeany ) + if ( ! gv->madeany ) { /* Create the '.' character class. */ - ccldot = cclinit(); - ccladd( ccldot, '\n' ); - cclnegate( ccldot ); + gv->ccldot = cclinit(); + ccladd( gv->ccldot, '\n' ); + cclnegate( gv->ccldot ); - if ( ctrl.useecs ) - mkeccl( ccltbl + cclmap[ccldot], - ccllen[ccldot], nextecm, - ecgroup, ctrl.csize, ctrl.csize ); + if ( gv->ctrl.useecs ) + mkeccl( gv->ccltbl + gv->cclmap[gv->ccldot], + gv->ccllen[gv->ccldot], gv->nextecm, + gv->ecgroup, gv->ctrl.csize, gv->ctrl.csize ); /* Create the (?s:'.') character class. */ - cclany = cclinit(); - cclnegate( cclany ); + gv->cclany = cclinit(); + cclnegate( gv->cclany ); - if ( ctrl.useecs ) - mkeccl( ccltbl + cclmap[cclany], - ccllen[cclany], nextecm, - ecgroup, ctrl.csize, ctrl.csize ); + if ( gv->ctrl.useecs ) + mkeccl( gv->ccltbl + gv->cclmap[gv->cclany], + gv->ccllen[gv->cclany],gv-> nextecm, + gv->ecgroup, gv->ctrl.csize, gv->ctrl.csize ); - madeany = true; + gv->madeany = true; } - ++rulelen; + ++gv->rulelen; if (sf_dot_all()) - $$ = mkstate( -cclany ); + $$ = mkstate( -gv->cclany ); else - $$ = mkstate( -ccldot ); + $$ = mkstate( -gv->ccldot ); } | fullccl { /* Sort characters for fast searching. */ - qsort( ccltbl + cclmap[$1], (size_t) ccllen[$1], sizeof (*ccltbl), cclcmp ); + qsort( gv->ccltbl + gv->cclmap[$1], (size_t) gv->ccllen[$1], sizeof (*gv->ccltbl), cclcmp ); - if ( ctrl.useecs ) - mkeccl( ccltbl + cclmap[$1], ccllen[$1], - nextecm, ecgroup, ctrl.csize, ctrl.csize); + if ( gv->ctrl.useecs ) + mkeccl( gv->ccltbl + gv->cclmap[$1], gv->ccllen[$1], + gv->nextecm, gv->ecgroup, gv->ctrl.csize, gv->ctrl.csize); - ++rulelen; + ++gv->rulelen; - if (ccl_has_nl[$1]) - rule_has_nl[num_rules] = true; + if (gv->ccl_has_nl[$1]) + gv->rule_has_nl[gv->num_rules] = true; $$ = mkstate( -$1 ); } | PREVCCL { - ++rulelen; + ++gv->rulelen; - if (ccl_has_nl[$1]) - rule_has_nl[num_rules] = true; + if (gv->ccl_has_nl[$1]) + gv->rule_has_nl[gv->num_rules] = true; $$ = mkstate( -$1 ); } @@ -781,10 +781,10 @@ singleton : singleton '*' | CHAR { - ++rulelen; + ++gv->rulelen; - if ($1 == nlch) - rule_has_nl[num_rules] = true; + if ($1 == gv->nlch) + gv->rule_has_nl[gv->num_rules] = true; if (sf_case_ins() && has_case($1)) /* create an alternation, as in (a|A) */ @@ -844,25 +844,25 @@ ccl : ccl CHAR '-' CHAR else { - for ( i = $2; i <= $4; ++i ) - ccladd( $1, i ); + for ( gv->i_parse = $2; gv->i_parse <= $4; ++gv->i_parse ) + ccladd( $1, gv->i_parse ); /* Keep track if this ccl is staying in * alphabetical order. */ - cclsorted = cclsorted && ($2 > lastchar); - lastchar = $4; + gv->cclsorted = gv->cclsorted && ($2 > gv->lastchar); + gv->lastchar = $4; /* Do it again for upper/lowercase */ if (sf_case_ins() && has_case($2) && has_case($4)){ $2 = reverse_case ($2); $4 = reverse_case ($4); - for ( i = $2; i <= $4; ++i ) - ccladd( $1, i ); + for ( gv->i_parse = $2; gv->i_parse <= $4; ++gv->i_parse ) + ccladd( $1, gv->i_parse ); - cclsorted = cclsorted && ($2 > lastchar); - lastchar = $4; + gv->cclsorted = gv->cclsorted && ($2 > gv->lastchar); + gv->lastchar = $4; } } @@ -873,16 +873,16 @@ ccl : ccl CHAR '-' CHAR | ccl CHAR { ccladd( $1, $2 ); - cclsorted = cclsorted && ($2 > lastchar); - lastchar = $2; + gv->cclsorted = gv->cclsorted && ($2 > gv->lastchar); + gv->lastchar = $2; /* Do it again for upper/lowercase */ if (sf_case_ins() && has_case($2)){ $2 = reverse_case ($2); ccladd ($1, $2); - cclsorted = cclsorted && ($2 > lastchar); - lastchar = $2; + gv->cclsorted = gv->cclsorted && ($2 > gv->lastchar); + gv->lastchar = $2; } $$ = $1; @@ -890,16 +890,16 @@ ccl : ccl CHAR '-' CHAR | ccl ccl_expr { - /* Too hard to properly maintain cclsorted. */ - cclsorted = false; + /* Too hard to properly maintain gv->cclsorted. */ + gv->cclsorted = false; $$ = $1; } | { - cclsorted = true; - lastchar = 0; - currccl = $$ = cclinit(); + gv->cclsorted = true; + gv->lastchar = 0; + gv->currccl = $$ = cclinit(); } ; @@ -951,10 +951,10 @@ ccl_expr: string : string CHAR { - if ( $2 == nlch ) - rule_has_nl[num_rules] = true; + if ( $2 == gv->nlch ) + gv->rule_has_nl[gv->num_rules] = true; - ++rulelen; + ++gv->rulelen; if (sf_case_ins() && has_case($2)) $$ = mkor (mkstate($2), mkstate(reverse_case($2))); @@ -980,27 +980,27 @@ void build_eof_action(void) int i; char action_text[MAXLINE]; - for ( i = 1; i <= scon_stk_ptr; ++i ) + for ( i = 1; i <= gv->scon_stk_ptr; ++i ) { - if ( sceof[scon_stk[i]] ) + if ( gv->sceof[gv->scon_stk[i]] ) format_pinpoint_message( "multiple <> rules for start condition %s", - scname[scon_stk[i]] ); + gv->scname[gv->scon_stk[i]] ); else { - sceof[scon_stk[i]] = true; + gv->sceof[gv->scon_stk[i]] = true; - if (previous_continued_action /* && previous action was regular */) + if (gv->previous_continued_action /* && previous action was regular */) add_action("YY_RULE_SETUP\n"); snprintf( action_text, sizeof(action_text), "M4_HOOK_EOF_STATE_CASE_ARM(%s)\n", - scname[scon_stk[i]] ); + gv->scname[gv->scon_stk[i]] ); add_action( action_text ); } } - line_directive_out(NULL, infilename, linenum); + line_directive_out(NULL, gv->infilename, gv->linenum); add_action("[["); /* This isn't a normal rule after all - don't count it as @@ -1008,8 +1008,8 @@ void build_eof_action(void) * (which make generating "rule can never match" warnings * more difficult. */ - --num_rules; - ++num_eof_rules; + --gv->num_rules; + ++gv->num_eof_rules; } @@ -1028,7 +1028,7 @@ void format_synerr( const char *msg, const char arg[] ) void synerr( const char *str ) { - syntaxerror = true; + gv->syntaxerror = true; pinpoint_message( str ); } @@ -1048,7 +1048,7 @@ void format_warn( const char *msg, const char arg[] ) void lwarn( const char *str ) { - line_warning( str, linenum ); + line_warning( str, gv->linenum ); } /* format_pinpoint_message - write out a message formatted with one string, @@ -1068,7 +1068,7 @@ void format_pinpoint_message( const char *msg, const char arg[] ) void pinpoint_message( const char *str ) { - line_pinpoint( str, linenum ); + line_pinpoint( str, gv->linenum ); } @@ -1078,7 +1078,7 @@ void line_warning( const char *str, int line ) { char warning[MAXLINE*2]; - if ( ! env.nowarn ) + if ( ! gv->env.nowarn ) { snprintf( warning, sizeof(warning), "warning, %s", str ); line_pinpoint( warning, line ); @@ -1090,7 +1090,7 @@ void line_warning( const char *str, int line ) void line_pinpoint( const char *str, int line ) { - fprintf( stderr, "%s:%d: %s\n", infilename, line, str ); + fprintf( stderr, "%s:%d: %s\n", gv->infilename, line, str ); } diff --git a/src/regex.c b/src/regex.c index 17a7aa5fd..18403b421 100644 --- a/src/regex.c +++ b/src/regex.c @@ -24,7 +24,7 @@ #include "flexdef.h" -regex_t regex_linedir; /**< matches line directives */ +//regex_t regex_linedir; /**< matches line directives */ /** Initialize the regular expressions. @@ -33,7 +33,7 @@ regex_t regex_linedir; /**< matches line directives */ bool flex_init_regex(const char *traceline_re) { if (traceline_re != NULL) - flex_regcomp(®ex_linedir, traceline_re, REG_EXTENDED); + flex_regcomp(&gv->regex_linedir, traceline_re, REG_EXTENDED); return true; } diff --git a/src/scan.l b/src/scan.l index 53e249873..c68f3e983 100644 --- a/src/scan.l +++ b/src/scan.l @@ -39,9 +39,9 @@ /* PURPOSE. */ #include "parse.h" -extern bool tablesverify, tablesext; -extern bool trlcontxt; /* Set in parse.y for each rule. */ -extern const char *escaped_qstart, *escaped_qend; +//extern bool tablesverify, tablesext; +//extern bool trlcontxt; /* Set in parse.y for each rule. */ +//extern const char *escaped_qstart, *escaped_qend; #define M4QSTART "[""[" #define M4QEND "]""]" @@ -65,7 +65,7 @@ extern const char *escaped_qstart, *escaped_qend; #define RETURNNAME \ if(yyleng < MAXLINE) \ { \ - strncpy( nmstr, yytext, sizeof(nmstr) ); \ + strncpy( gv->nmstr, yytext, sizeof(gv->nmstr) ); \ return NAME; \ } \ else \ @@ -82,31 +82,31 @@ extern const char *escaped_qstart, *escaped_qend; #define CHECK_REJECT(str) \ if ( all_upper( str ) ) \ - reject = true; + gv->reject = true; #define CHECK_YYREJECT(str) \ if ( all_lower( str ) ) \ - reject = true; + gv->reject = true; #define YY_USER_INIT \ if ( getenv("POSIXLY_CORRECT") ) \ - ctrl.posix_compat = true; + gv->ctrl.posix_compat = true; #define START_CODEBLOCK(x) do { \ /* Emit the needed line directive... */\ - if (indented_code == false) { \ - if (!x) linenum++; \ - line_directive_out(NULL, infilename, linenum); \ + if (gv->indented_code == false) { \ + if (!x) gv->linenum++; \ + line_directive_out(NULL, gv->infilename, gv->linenum); \ } \ add_action(M4QSTART); \ yy_push_state(CODEBLOCK); \ - if ((indented_code = x)) ACTION_ECHO; \ + if ((gv->indented_code = x)) ACTION_ECHO; \ } while(0) #define END_CODEBLOCK do { \ yy_pop_state();\ add_action(M4QEND); \ - if (!indented_code) line_directive_out(NULL, NULL, linenum); \ + if (!gv->indented_code) line_directive_out(NULL, NULL, gv->linenum); \ } while (0) %} @@ -154,13 +154,13 @@ void context_member(char *, const char *); #undef yyreject %} %% - static int bracelevel, didadef, indented_code; - static bool doing_rule_action = false; - static bool option_sense; + //static int bracelevel, didadef, indented_code; + //static bool doing_rule_action = false; + //static bool option_sense; - static bool doing_codeblock = false; - int brace_depth=0, brace_start_line=0; - char nmdef[MAXLINE]; + //static bool doing_codeblock = false; + //int brace_depth=0, brace_start_line=0; + //char nmdef[MAXLINE]; { @@ -172,13 +172,13 @@ void context_member(char *, const char *); ^"%{".*{NL} START_CODEBLOCK(false); ^"%top"[[:blank:]]*"{"[[:blank:]]*{NL} { char trampoline[512]; - brace_start_line = linenum; - ++linenum; + gv->brace_start_line = gv->linenum; + ++gv->linenum; snprintf(trampoline, sizeof(trampoline), "M4_HOOK_TRACE_LINE_FORMAT(%d, [[%s]])", - linenum, infilename?infilename:""); - buf_strappend(&top_buf, trampoline); - brace_depth = 1; + gv->linenum, gv->infilename?gv->infilename:""); + buf_strappend(&gv->top_buf, trampoline); + gv->brace_depth = 1; yy_push_state(CODEBLOCK_MATCH_BRACE); } @@ -187,21 +187,21 @@ void context_member(char *, const char *); {WS} /* discard */ ^"%%".* { - sectnum = 2; - bracelevel = 0; + gv->sectnum = 2; + gv->bracelevel = 0; mark_defs1(); - line_directive_out(NULL, infilename, linenum); + line_directive_out(NULL, gv->infilename, gv->linenum); BEGIN(SECT2PROLOG); return SECTEND; } - ^"%pointer".*{NL} ctrl.yytext_is_array = false; ++linenum; - ^"%array".*{NL} ctrl.yytext_is_array = true; ++linenum; + ^"%pointer".*{NL} gv->ctrl.yytext_is_array = false; ++gv->linenum; + ^"%array".*{NL} gv->ctrl.yytext_is_array = true; ++gv->linenum; ^"%option" BEGIN(OPTION); return TOK_OPTION; - ^"%"{LEXOPT}{OPTWS}[[:digit:]]*{OPTWS}{NL} ++linenum; /* ignore */ - ^"%"{LEXOPT}{WS}.*{NL} ++linenum; /* ignore */ + ^"%"{LEXOPT}{OPTWS}[[:digit:]]*{OPTWS}{NL} ++gv->linenum; /* ignore */ + ^"%"{LEXOPT}{WS}.*{NL} ++gv->linenum; /* ignore */ /* xgettext: no-c-format */ ^"%"[^sxaceknopr{}].* synerr( _( "unrecognized '%' directive" ) ); @@ -209,7 +209,7 @@ void context_member(char *, const char *); ^{NAME} { if(yyleng < MAXLINE) { - strncpy( nmstr, yytext, sizeof(nmstr) ); + strncpy( gv->nmstr, yytext, sizeof(gv->nmstr) ); } else { @@ -217,13 +217,13 @@ void context_member(char *, const char *); FLEX_EXIT(EXIT_FAILURE); } - didadef = false; + gv->didadef = false; BEGIN(PICKUPDEF); } {SCNAME} RETURNNAME; - ^{OPTWS}{NL} ++linenum; /* allows blank lines in section 1 */ - {OPTWS}{NL} ACTION_ECHO; ++linenum; /* maybe end of comment line */ + ^{OPTWS}{NL} ++gv->linenum; /* allows blank lines in section 1 */ + {OPTWS}{NL} ACTION_ECHO; ++gv->linenum; /* maybe end of comment line */ } @@ -231,7 +231,7 @@ void context_member(char *, const char *); [^\[\]\*\n]* ACTION_ECHO; . ACTION_ECHO; - {NL} ++linenum; ACTION_ECHO; + {NL} ++gv->linenum; ACTION_ECHO; } { "*/" add_action("*/]""]"); yy_pop_state(); @@ -245,23 +245,23 @@ void context_member(char *, const char *); "*/" yy_pop_state(); "*" ; [^*\n] ; - {NL} ++linenum; + {NL} ++gv->linenum; } { ")" yy_pop_state(); [^\n\)]+ ; - {NL} ++linenum; + {NL} ++gv->linenum; } { \n yy_pop_state(); - [[:digit:]]+ linenum = myctoi( yytext ); + [[:digit:]]+ gv->linenum = myctoi( yytext ); "\""[^""\n]*"\"" { - free(infilename); - infilename = xstrdup(yytext + 1); - infilename[strlen( infilename ) - 1] = '\0'; + free(gv->infilename); + gv->infilename = xstrdup(yytext + 1); + gv->infilename[strlen( gv->infilename ) - 1] = '\0'; } . /* ignore spurious characters */ } @@ -271,43 +271,43 @@ void context_member(char *, const char *); } { - ^"%}".*{NL} ++linenum; END_CODEBLOCK; + ^"%}".*{NL} ++gv->linenum; END_CODEBLOCK; [^\n%\[\]]* ACTION_ECHO; . ACTION_ECHO; {NL} { - ++linenum; + ++gv->linenum; ACTION_ECHO; - if ( indented_code ) END_CODEBLOCK; + if ( gv->indented_code ) END_CODEBLOCK; } } { "}" { - if( --brace_depth == 0){ + if( --gv->brace_depth == 0){ /* TODO: Matched. */ yy_pop_state(); }else - buf_strnappend(&top_buf, yytext, yyleng); + buf_strnappend(&gv->top_buf, yytext, yyleng); } "{" { - brace_depth++; - buf_strnappend(&top_buf, yytext, yyleng); + gv->brace_depth++; + buf_strnappend(&gv->top_buf, yytext, yyleng); } {NL} { - ++linenum; - buf_strnappend(&top_buf, yytext, yyleng); + ++gv->linenum; + buf_strnappend(&gv->top_buf, yytext, yyleng); } - {M4QSTART} buf_strnappend(&top_buf, escaped_qstart, (int) strlen(escaped_qstart)); - {M4QEND} buf_strnappend(&top_buf, escaped_qend, (int) strlen(escaped_qend)); + {M4QSTART} buf_strnappend(&gv->top_buf, gv->escaped_qstart, (int) strlen(gv->escaped_qstart)); + {M4QEND} buf_strnappend(&gv->top_buf, gv->escaped_qend, (int) strlen(gv->escaped_qend)); ([^{}\r\n\[\]]+)|[^{}\r\n] { - buf_strnappend(&top_buf, yytext, yyleng); + buf_strnappend(&gv->top_buf, yytext, yyleng); } <> { - linenum = brace_start_line; + gv->linenum = gv->brace_start_line; synerr(_("Unmatched '{'")); return YY_NULL; } @@ -320,140 +320,140 @@ void context_member(char *, const char *); {NOT_WS}[^\r\n]* { if(yyleng < MAXLINE) { - strncpy( nmdef, yytext, sizeof(nmdef) ); + strncpy( gv->nmdef, yytext, sizeof(gv->nmdef) ); } else { - format_synerr( _("Definition value for {%s} too long\n"), nmstr); + format_synerr( _("Definition value for {%s} too long\n"), gv->nmstr); FLEX_EXIT(EXIT_FAILURE); } /* Skip trailing whitespace. */ { - size_t i = strlen( nmdef ); - while (i > 0 && (nmdef[i-1] == ' ' || nmdef[i-1] == '\t')) + size_t i = strlen( gv->nmdef ); + while (i > 0 && (gv->nmdef[i-1] == ' ' || gv->nmdef[i-1] == '\t')) --i; - nmdef[i] = '\0'; + gv->nmdef[i] = '\0'; } - ndinstal( nmstr, nmdef ); - didadef = true; + ndinstal( gv->nmstr, gv->nmdef ); + gv->didadef = true; } {NL} { - if ( ! didadef ) + if ( ! gv->didadef ) synerr( _( "incomplete name definition" ) ); BEGIN(INITIAL); - ++linenum; + ++gv->linenum; } }