=================================================================== RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/lex/misc.c,v retrieving revision 1.15 retrieving revision 1.16 diff -u -r1.15 -r1.16 --- src/usr.bin/lex/misc.c 2015/11/19 19:43:40 1.15 +++ src/usr.bin/lex/misc.c 2015/11/19 22:52:40 1.16 @@ -1,4 +1,4 @@ -/* $OpenBSD: misc.c,v 1.15 2015/11/19 19:43:40 tedu Exp $ */ +/* $OpenBSD: misc.c,v 1.16 2015/11/19 22:52:40 tedu Exp $ */ /* misc - miscellaneous flex routines */ @@ -54,64 +54,66 @@ /* we allow the skeleton to push and pop. */ struct sko_state { - bool dc; /**< do_copy */ + bool dc; /**< do_copy */ }; -static struct sko_state *sko_stack=0; -static int sko_len=0,sko_sz=0; -static void sko_push(bool dc) +static struct sko_state *sko_stack = 0; +static int sko_len = 0, sko_sz = 0; +static void +sko_push(bool dc) { - if(!sko_stack){ - sko_sz = 1; - sko_stack = (struct sko_state*)flex_alloc(sizeof(struct sko_state)*sko_sz); - if (!sko_stack) - flexfatal(_("allocation of sko_stack failed")); - sko_len = 0; - } - if(sko_len >= sko_sz){ - sko_sz *= 2; - sko_stack = (struct sko_state*)flex_realloc(sko_stack,sizeof(struct sko_state)*sko_sz); - } - - /* initialize to zero and push */ - sko_stack[sko_len].dc = dc; - sko_len++; + if (!sko_stack) { + sko_sz = 1; + sko_stack = (struct sko_state *) flex_alloc(sizeof(struct sko_state) * sko_sz); + if (!sko_stack) + flexfatal(_("allocation of sko_stack failed")); + sko_len = 0; + } + if (sko_len >= sko_sz) { + sko_sz *= 2; + sko_stack = (struct sko_state *) flex_realloc(sko_stack, sizeof(struct sko_state) * sko_sz); + } + /* initialize to zero and push */ + sko_stack[sko_len].dc = dc; + sko_len++; } -static void sko_peek(bool *dc) +static void +sko_peek(bool * dc) { - if(sko_len <= 0) - flex_die("peek attempt when sko stack is empty"); - if(dc) - *dc = sko_stack[sko_len-1].dc; + if (sko_len <= 0) + flex_die("peek attempt when sko stack is empty"); + if (dc) + *dc = sko_stack[sko_len - 1].dc; } -static void sko_pop(bool* dc) +static void +sko_pop(bool * dc) { - sko_peek(dc); - sko_len--; - if(sko_len < 0) - flex_die("popped too many times in skeleton."); + sko_peek(dc); + sko_len--; + if (sko_len < 0) + flex_die("popped too many times in skeleton."); } /* Append "#define defname value\n" to the running buffer. */ -void action_define (defname, value) - const char *defname; - int value; +void +action_define(defname, value) + const char *defname; + int value; { - char buf[MAXLINE]; - char *cpy; + char buf[MAXLINE]; + char *cpy; - if ((int) strlen (defname) > MAXLINE / 2) { - format_pinpoint_message (_ - ("name \"%s\" ridiculously long"), - defname); + if ((int) strlen(defname) > MAXLINE / 2) { + format_pinpoint_message(_ + ("name \"%s\" ridiculously long"), + defname); return; } + snprintf(buf, sizeof(buf), "#define %s %d\n", defname, value); + add_action(buf); - snprintf (buf, sizeof(buf), "#define %s %d\n", defname, value); - add_action (buf); - /* track #defines so we can undef them when we're done. */ - cpy = copy_string (defname); - buf_append (&defs_buf, &cpy, 1); + cpy = copy_string(defname); + buf_append(&defs_buf, &cpy, 1); } @@ -119,34 +121,36 @@ * @param defname The macro name. * @param value The macro value, can be NULL, which is the same as the empty string. */ -void action_m4_define (const char *defname, const char * value) +void +action_m4_define(const char *defname, const char *value) { - char buf[MAXLINE]; + char buf[MAXLINE]; - flexfatal ("DO NOT USE THIS FUNCTION!"); + flexfatal("DO NOT USE THIS FUNCTION!"); - if ((int) strlen (defname) > MAXLINE / 2) { - format_pinpoint_message (_ - ("name \"%s\" ridiculously long"), - defname); + if ((int) strlen(defname) > MAXLINE / 2) { + format_pinpoint_message(_ + ("name \"%s\" ridiculously long"), + defname); return; } - - snprintf (buf, sizeof(buf), "m4_define([[%s]],[[%s]])m4_dnl\n", defname, value?value:""); - add_action (buf); + snprintf(buf, sizeof(buf), "m4_define([[%s]],[[%s]])m4_dnl\n", defname, value ? value : ""); + add_action(buf); } /* Append "new_text" to the running buffer. */ -void add_action (new_text) - const char *new_text; +void +add_action(new_text) + const char *new_text; { - int len = strlen (new_text); + int len = strlen(new_text); while (len + action_index >= action_size - 10 /* slop */ ) { - int new_size = action_size * 2; + int new_size = action_size * 2; if (new_size <= 0) - /* Increase just a little, to try to avoid overflow + /* + * Increase just a little, to try to avoid overflow * on 16-bit machines. */ action_size += action_size / 8; @@ -154,12 +158,12 @@ action_size = new_size; action_array = - reallocate_character_array (action_array, - action_size); + reallocate_character_array(action_array, + action_size); } - strlcpy ( &action_array[action_index], new_text, - action_size - action_index ); + strlcpy(&action_array[action_index], new_text, + action_size - action_index); action_index += len; } @@ -167,17 +171,18 @@ /* allocate_array - allocate memory for an integer array of the given size */ -void *allocate_array (size, element_size) - int size; - size_t element_size; +void * +allocate_array(size, element_size) + int size; + size_t element_size; { void *mem; - size_t num_bytes = element_size * size; + size_t num_bytes = element_size * size; - mem = flex_alloc (num_bytes); + mem = flex_alloc(num_bytes); if (!mem) - flexfatal (_ - ("memory allocation failed in allocate_array()")); + flexfatal(_ + ("memory allocation failed in allocate_array()")); return mem; } @@ -185,11 +190,12 @@ /* all_lower - true if a string is all lower-case */ -int all_lower (str) - char *str; +int +all_lower(str) + char *str; { while (*str) { - if (!isascii ((Char) * str) || !islower ((Char) * str)) + if (!isascii((Char) * str) || !islower((Char) * str)) return 0; ++str; } @@ -200,11 +206,12 @@ /* all_upper - true if a string is all upper-case */ -int all_upper (str) - char *str; +int +all_upper(str) + char *str; { while (*str) { - if (!isascii ((Char) * str) || !isupper ((Char) * str)) + if (!isascii((Char) * str) || !isupper((Char) * str)) return 0; ++str; } @@ -215,9 +222,10 @@ /* intcmp - compares two integers for use by qsort. */ -int intcmp (const void *a, const void *b) +int +intcmp(const void *a, const void *b) { - return *(const int *) a - *(const int *) b; + return *(const int *) a - *(const int *) b; } @@ -226,51 +234,54 @@ * and exits. */ -void check_char (c) - int c; +void +check_char(c) + int c; { if (c >= CSIZE) - lerrsf (_("bad character '%s' detected in check_char()"), - readable_form (c)); + lerrsf(_("bad character '%s' detected in check_char()"), + readable_form(c)); if (c >= csize) - lerrsf (_ - ("scanner requires -8 flag to use the character %s"), - readable_form (c)); + lerrsf(_ + ("scanner requires -8 flag to use the character %s"), + readable_form(c)); } /* clower - replace upper-case letter to lower-case */ -Char clower (c) - int c; +Char +clower(c) + int c; { - return (Char) ((isascii (c) && isupper (c)) ? tolower (c) : c); + return (Char) ((isascii(c) && isupper(c)) ? tolower(c) : c); } /* copy_string - returns a dynamically allocated copy of a string */ -char *copy_string (str) - const char *str; +char * +copy_string(str) + const char *str; { const char *c1; char *c2; - char *copy; + char *copy; unsigned int size; /* find length */ - for (c1 = str; *c1; ++c1) ; + for (c1 = str; *c1; ++c1); - size = (c1 - str + 1) * sizeof (char); + size = (c1 - str + 1) * sizeof(char); - copy = (char *) flex_alloc (size); + copy = (char *) flex_alloc(size); if (copy == NULL) - flexfatal (_("dynamic memory failure in copy_string()")); + flexfatal(_("dynamic memory failure in copy_string()")); - for (c2 = copy; (*c2++ = *str++) != 0;) ; + for (c2 = copy; (*c2++ = *str++) != 0;); return copy; } @@ -280,18 +291,19 @@ * returns a dynamically allocated copy of a (potentially) unsigned string */ -Char *copy_unsigned_string (str) - Char *str; +Char * +copy_unsigned_string(str) + Char *str; { Char *c; - Char *copy; + Char *copy; /* find length */ - for (c = str; *c; ++c) ; + for (c = str; *c; ++c); - copy = allocate_Character_array (c - str + 1); + copy = allocate_Character_array(c - str + 1); - for (c = copy; (*c++ = *str++) != 0;) ; + for (c = copy; (*c++ = *str++) != 0;); return copy; } @@ -299,30 +311,31 @@ /* cclcmp - compares two characters for use by qsort with '\0' sorting last. */ -int cclcmp (const void *a, const void *b) +int +cclcmp(const void *a, const void *b) { - if (!*(const Char *) a) - return 1; - else - if (!*(const Char *) b) - return - 1; + if (!*(const Char *) a) + return 1; + else if (!*(const Char *) b) + return -1; else - return *(const Char *) a - *(const Char *) b; + return *(const Char *) a - *(const Char *) b; } /* dataend - finish up a block of data declarations */ -void dataend () +void +dataend() { /* short circuit any output */ if (gentables) { if (datapos > 0) - dataflush (); + dataflush(); /* add terminator for initialization; { for vi */ - outn (" } ;\n"); + outn(" } ;\n"); } dataline = 0; datapos = 0; @@ -331,22 +344,23 @@ /* dataflush - flush generated data statements */ -void dataflush () +void +dataflush() { /* short circuit any output */ if (!gentables) return; - outc ('\n'); + outc('\n'); if (++dataline >= NUMDATALINES) { - /* Put out a blank line so that the table is grouped into + /* + * Put out a blank line so that the table is grouped into * large blocks that enable the user to find elements easily. */ - outc ('\n'); + outc('\n'); dataline = 0; } - /* Reset the number of characters written on the current line. */ datapos = 0; } @@ -354,33 +368,36 @@ /* flexerror - report an error message and terminate */ -void flexerror (msg) - const char *msg; +void +flexerror(msg) + const char *msg; { - fprintf (stderr, "%s: %s\n", program_name, msg); - flexend (1); + fprintf(stderr, "%s: %s\n", program_name, msg); + flexend(1); } /* flexfatal - report a fatal error message and terminate */ -void flexfatal (msg) - const char *msg; +void +flexfatal(msg) + const char *msg; { - fprintf (stderr, _("%s: fatal internal error, %s\n"), - program_name, msg); - FLEX_EXIT (1); + fprintf(stderr, _("%s: fatal internal error, %s\n"), + program_name, msg); + FLEX_EXIT(1); } /* htoi - convert a hexadecimal digit string to an integer value */ -int htoi (str) - Char str[]; +int +htoi(str) + Char str[]; { unsigned int result; - (void) sscanf ((char *) str, "%x", &result); + (void) sscanf((char *) str, "%x", &result); return result; } @@ -388,51 +405,55 @@ /* lerrif - report an error message formatted with one integer argument */ -void lerrif (msg, arg) - const char *msg; - int arg; +void +lerrif(msg, arg) + const char *msg; + int arg; { - char errmsg[MAXLINE]; + char errmsg[MAXLINE]; - snprintf (errmsg, sizeof(errmsg), msg, arg); - flexerror (errmsg); + snprintf(errmsg, sizeof(errmsg), msg, arg); + flexerror(errmsg); } /* lerrsf - report an error message formatted with one string argument */ -void lerrsf (msg, arg) +void +lerrsf(msg, arg) const char *msg, arg[]; { - char errmsg[MAXLINE]; + char errmsg[MAXLINE]; - snprintf (errmsg, sizeof(errmsg)-1, msg, arg); - errmsg[sizeof(errmsg)-1] = 0; /* ensure NULL termination */ - flexerror (errmsg); + snprintf(errmsg, sizeof(errmsg) - 1, msg, arg); + errmsg[sizeof(errmsg) - 1] = 0; /* ensure NULL termination */ + flexerror(errmsg); } /* lerrsf_fatal - as lerrsf, but call flexfatal */ -void lerrsf_fatal (msg, arg) +void +lerrsf_fatal(msg, arg) const char *msg, arg[]; { - char errmsg[MAXLINE]; + char errmsg[MAXLINE]; - snprintf (errmsg, sizeof(errmsg)-1, msg, arg); - errmsg[sizeof(errmsg)-1] = 0; /* ensure NULL termination */ - flexfatal (errmsg); + snprintf(errmsg, sizeof(errmsg) - 1, msg, arg); + errmsg[sizeof(errmsg) - 1] = 0; /* ensure NULL termination */ + flexfatal(errmsg); } /* line_directive_out - spit out a "#line" statement */ -void line_directive_out (output_file, do_infile) - FILE *output_file; - int do_infile; +void +line_directive_out(output_file, do_infile) + FILE *output_file; + int do_infile; { - char directive[MAXLINE], filename[MAXLINE]; - char *s1, *s2, *s3; + char directive[MAXLINE], filename[MAXLINE]; + char *s1, *s2, *s3; static const char *line_fmt = "#line %d \"%s\"\n"; if (!gen_line_dirs) @@ -441,10 +462,10 @@ s1 = do_infile ? infilename : "M4_YY_OUTFILE_NAME"; if (do_infile && !s1) - s1 = ""; - + s1 = ""; + s2 = filename; - s3 = &filename[sizeof (filename) - 2]; + s3 = &filename[sizeof(filename) - 2]; while (s2 < s3 && *s1) { if (*s1 == '\\') @@ -457,19 +478,19 @@ *s2 = '\0'; if (do_infile) - snprintf (directive, sizeof(directive), line_fmt, linenum, filename); + snprintf(directive, sizeof(directive), line_fmt, linenum, filename); else { - snprintf (directive, sizeof(directive), line_fmt, 0, filename); + snprintf(directive, sizeof(directive), line_fmt, 0, filename); } - /* If output_file is nil then we should put the directive in - * the accumulated actions. + /* + * If output_file is nil then we should put the directive in the + * accumulated actions. */ if (output_file) { - fputs (directive, output_file); - } - else - add_action (directive); + fputs(directive, output_file); + } else + add_action(directive); } @@ -477,7 +498,8 @@ * representing where the user's section 1 definitions end * and the prolog begins */ -void mark_defs1 () +void +mark_defs1() { defs1_offset = 0; action_array[action_index++] = '\0'; @@ -489,7 +511,8 @@ /* mark_prolog - mark the current position in the action array as * representing the end of the action prolog */ -void mark_prolog () +void +mark_prolog() { action_array[action_index++] = '\0'; action_offset = action_index; @@ -501,28 +524,28 @@ * * Generates a data statement initializing the current 2-D array to "value". */ -void mk2data (value) - int value; +void +mk2data(value) + int value; { /* short circuit any output */ if (!gentables) return; if (datapos >= NUMDATAITEMS) { - outc (','); - dataflush (); + outc(','); + dataflush(); } - if (datapos == 0) /* Indent. */ - out (" "); + out(" "); else - outc (','); + outc(','); ++datapos; - out_dec ("%5d", value); + out_dec("%5d", value); } @@ -531,38 +554,39 @@ * Generates a data statement initializing the current array element to * "value". */ -void mkdata (value) - int value; +void +mkdata(value) + int value; { /* short circuit any output */ if (!gentables) return; if (datapos >= NUMDATAITEMS) { - outc (','); - dataflush (); + outc(','); + dataflush(); } - if (datapos == 0) /* Indent. */ - out (" "); + out(" "); else - outc (','); + outc(','); ++datapos; - out_dec ("%5d", value); + out_dec("%5d", value); } /* myctoi - return the integer represented by a string of digits */ -int myctoi (array) - const char *array; +int +myctoi(array) + const char *array; { - int val = 0; + int val = 0; - (void) sscanf (array, "%d", &val); + (void) sscanf(array, "%d", &val); return val; } @@ -570,10 +594,11 @@ /* myesc - return character corresponding to escape sequence */ -Char myesc (array) - Char array[]; +Char +myesc(array) + Char array[]; { - Char c, esc_char; + Char c, esc_char; switch (array[1]) { case 'b': @@ -608,11 +633,12 @@ case '6': case '7': { /* \ */ - int sptr = 1; + int sptr = 1; - while (isascii (array[sptr]) && - isdigit (array[sptr])) - /* Don't increment inside loop control + while (isascii(array[sptr]) && + isdigit(array[sptr])) + /* + * Don't increment inside loop control * because if isdigit() is a macro it might * expand into multiple increments ... */ @@ -621,7 +647,7 @@ c = array[sptr]; array[sptr] = '\0'; - esc_char = otoi (array + 1); + esc_char = otoi(array + 1); array[sptr] = c; @@ -630,11 +656,12 @@ case 'x': { /* \x */ - int sptr = 2; + int sptr = 2; - while (isascii (array[sptr]) && - isxdigit (array[sptr])) - /* Don't increment inside loop control + while (isascii(array[sptr]) && + isxdigit(array[sptr])) + /* + * Don't increment inside loop control * because if isdigit() is a macro it might * expand into multiple increments ... */ @@ -643,7 +670,7 @@ c = array[sptr]; array[sptr] = '\0'; - esc_char = htoi (array + 2); + esc_char = htoi(array + 2); array[sptr] = c; @@ -658,12 +685,13 @@ /* otoi - convert an octal digit string to an integer value */ -int otoi (str) - Char str[]; +int +otoi(str) + Char str[]; { unsigned int result; - (void) sscanf ((char *) str, "%o", &result); + (void) sscanf((char *) str, "%o", &result); return result; } @@ -672,63 +700,72 @@ * generated scanner, keeping track of the line count. */ -void out (str) - const char *str; +void +out(str) + const char *str; { - fputs (str, stdout); + fputs(str, stdout); } -void out_dec (fmt, n) - const char *fmt; - int n; +void +out_dec(fmt, n) + const char *fmt; + int n; { - fprintf (stdout, fmt, n); + fprintf(stdout, fmt, n); } -void out_dec2 (fmt, n1, n2) - const char *fmt; - int n1, n2; +void +out_dec2(fmt, n1, n2) + const char *fmt; + int n1, n2; { - fprintf (stdout, fmt, n1, n2); + fprintf(stdout, fmt, n1, n2); } -void out_hex (fmt, x) - const char *fmt; - unsigned int x; +void +out_hex(fmt, x) + const char *fmt; + unsigned int x; { - fprintf (stdout, fmt, x); + fprintf(stdout, fmt, x); } -void out_str (fmt, str) - const char *fmt, str[]; +void +out_str(fmt, str) + const char *fmt, str[]; { - fprintf (stdout,fmt, str); + fprintf(stdout, fmt, str); } -void out_str3 (fmt, s1, s2, s3) - const char *fmt, s1[], s2[], s3[]; +void +out_str3(fmt, s1, s2, s3) + const char *fmt, s1[], s2[], s3[]; { - fprintf (stdout,fmt, s1, s2, s3); + fprintf(stdout, fmt, s1, s2, s3); } -void out_str_dec (fmt, str, n) - const char *fmt, str[]; - int n; +void +out_str_dec(fmt, str, n) + const char *fmt, str[]; + int n; { - fprintf (stdout,fmt, str, n); + fprintf(stdout, fmt, str, n); } -void outc (c) - int c; +void +outc(c) + int c; { - fputc (c, stdout); + fputc(c, stdout); } -void outn (str) - const char *str; +void +outn(str) + const char *str; { - fputs (str,stdout); - fputc('\n',stdout); + fputs(str, stdout); + fputc('\n', stdout); } /** Print "m4_define( [[def]], [[val]])m4_dnl\n". @@ -736,10 +773,11 @@ * @param val The definition; may be NULL. * @return buf */ -void out_m4_define (const char* def, const char* val) +void +out_m4_define(const char *def, const char *val) { - const char * fmt = "m4_define( [[%s]], [[%s]])m4_dnl\n"; - fprintf(stdout, fmt, def, val?val:""); + const char *fmt = "m4_define( [[%s]], [[%s]])m4_dnl\n"; + fprintf(stdout, fmt, def, val ? val : ""); } @@ -748,8 +786,9 @@ * The returned string is in static storage. */ -char *readable_form (c) - int c; +char * +readable_form(c) + int c; { static char rform[10]; @@ -774,12 +813,10 @@ #endif default: - snprintf (rform, sizeof(rform), "\\%.3o", (unsigned int) c); + snprintf(rform, sizeof(rform), "\\%.3o", (unsigned int) c); return rform; } - } - - else if (c == ' ') + } else if (c == ' ') return "' '"; else { @@ -793,17 +830,18 @@ /* reallocate_array - increase the size of a dynamic array */ -void *reallocate_array (array, size, element_size) - void *array; - int size; - size_t element_size; +void * +reallocate_array(array, size, element_size) + void *array; + int size; + size_t element_size; { void *new_array; - size_t num_bytes = element_size * size; + size_t num_bytes = element_size * size; - new_array = flex_realloc (array, num_bytes); + new_array = flex_realloc(array, num_bytes); if (!new_array) - flexfatal (_("attempt to increase array size failed")); + flexfatal(_("attempt to increase array size failed")); return new_array; } @@ -815,127 +853,111 @@ * Copies skelfile or skel array to stdout until a line beginning with * "%%" or EOF is found. */ -void skelout () +void +skelout() { - char buf_storage[MAXLINE]; - char *buf = buf_storage; - bool do_copy = true; + char buf_storage[MAXLINE]; + char *buf = buf_storage; + bool do_copy = true; - /* "reset" the state by clearing the buffer and pushing a '1' */ - if(sko_len > 0) - sko_peek(&do_copy); - sko_len = 0; - sko_push(do_copy=true); + /* "reset" the state by clearing the buffer and pushing a '1' */ + if (sko_len > 0) + sko_peek(&do_copy); + sko_len = 0; + sko_push(do_copy = true); - /* Loop pulling lines either from the skelfile, if we're using - * one, or from the skel[] array. + /* + * Loop pulling lines either from the skelfile, if we're using one, + * or from the skel[] array. */ while (skelfile ? - (fgets (buf, MAXLINE, skelfile) != NULL) : - ((buf = (char *) skel[skel_ind++]) != 0)) { + (fgets(buf, MAXLINE, skelfile) != NULL) : + ((buf = (char *) skel[skel_ind++]) != 0)) { if (skelfile) - chomp (buf); + chomp(buf); /* copy from skel array */ if (buf[0] == '%') { /* control line */ /* print the control line as a comment. */ if (ddebug && buf[1] != '#') { - if (buf[strlen (buf) - 1] == '\\') - out_str ("/* %s */\\\n", buf); + if (buf[strlen(buf) - 1] == '\\') + out_str("/* %s */\\\n", buf); else - out_str ("/* %s */\n", buf); + out_str("/* %s */\n", buf); } - - /* We've been accused of using cryptic markers in the skel. - * So we'll use emacs-style-hyphenated-commands. - * We might consider a hash if this if-else-if-else - * chain gets too large. + /* + * We've been accused of using cryptic markers in the + * skel. So we'll use + * emacs-style-hyphenated-commands. We might consider + * a hash if this if-else-if-else chain gets too + * large. */ #define cmd_match(s) (strncmp(buf,(s),strlen(s))==0) if (buf[1] == '%') { /* %% is a break point for skelout() */ return; - } - else if (cmd_match (CMD_PUSH)){ - sko_push(do_copy); - if(ddebug){ - out_str("/*(state = (%s) */",do_copy?"true":"false"); - } - out_str("%s\n", buf[strlen (buf) - 1] =='\\' ? "\\" : ""); - } - else if (cmd_match (CMD_POP)){ - sko_pop(&do_copy); - if(ddebug){ - out_str("/*(state = (%s) */",do_copy?"true":"false"); - } - out_str("%s\n", buf[strlen (buf) - 1] =='\\' ? "\\" : ""); - } - else if (cmd_match (CMD_IF_REENTRANT)){ - sko_push(do_copy); - do_copy = reentrant && do_copy; - } - else if (cmd_match (CMD_IF_NOT_REENTRANT)){ - sko_push(do_copy); - do_copy = !reentrant && do_copy; - } - else if (cmd_match(CMD_IF_BISON_BRIDGE)){ - sko_push(do_copy); - do_copy = bison_bridge_lval && do_copy; - } - else if (cmd_match(CMD_IF_NOT_BISON_BRIDGE)){ - sko_push(do_copy); - do_copy = !bison_bridge_lval && do_copy; - } - else if (cmd_match (CMD_ENDIF)){ - sko_pop(&do_copy); - } - else if (cmd_match (CMD_IF_TABLES_SER)) { - do_copy = do_copy && tablesext; - } - else if (cmd_match (CMD_TABLES_YYDMAP)) { + } else if (cmd_match(CMD_PUSH)) { + sko_push(do_copy); + if (ddebug) { + out_str("/*(state = (%s) */", do_copy ? "true" : "false"); + } + out_str("%s\n", buf[strlen(buf) - 1] == '\\' ? "\\" : ""); + } else if (cmd_match(CMD_POP)) { + sko_pop(&do_copy); + if (ddebug) { + out_str("/*(state = (%s) */", do_copy ? "true" : "false"); + } + out_str("%s\n", buf[strlen(buf) - 1] == '\\' ? "\\" : ""); + } else if (cmd_match(CMD_IF_REENTRANT)) { + sko_push(do_copy); + do_copy = reentrant && do_copy; + } else if (cmd_match(CMD_IF_NOT_REENTRANT)) { + sko_push(do_copy); + do_copy = !reentrant && do_copy; + } else if (cmd_match(CMD_IF_BISON_BRIDGE)) { + sko_push(do_copy); + do_copy = bison_bridge_lval && do_copy; + } else if (cmd_match(CMD_IF_NOT_BISON_BRIDGE)) { + sko_push(do_copy); + do_copy = !bison_bridge_lval && do_copy; + } else if (cmd_match(CMD_ENDIF)) { + sko_pop(&do_copy); + } else if (cmd_match(CMD_IF_TABLES_SER)) { + do_copy = do_copy && tablesext; + } else if (cmd_match(CMD_TABLES_YYDMAP)) { if (tablesext && yydmap_buf.elts) - outn ((char *) (yydmap_buf.elts)); - } - else if (cmd_match (CMD_DEFINE_YYTABLES)) { - out_str("#define YYTABLES_NAME \"%s\"\n", - tablesname?tablesname:"yytables"); - } - else if (cmd_match (CMD_IF_CPP_ONLY)) { + outn((char *) (yydmap_buf.elts)); + } else if (cmd_match(CMD_DEFINE_YYTABLES)) { + out_str("#define YYTABLES_NAME \"%s\"\n", + tablesname ? tablesname : "yytables"); + } else if (cmd_match(CMD_IF_CPP_ONLY)) { /* only for C++ */ - sko_push(do_copy); + sko_push(do_copy); do_copy = C_plus_plus; - } - else if (cmd_match (CMD_IF_C_ONLY)) { + } else if (cmd_match(CMD_IF_C_ONLY)) { /* %- only for C */ - sko_push(do_copy); + sko_push(do_copy); do_copy = !C_plus_plus; - } - else if (cmd_match (CMD_IF_C_OR_CPP)) { + } else if (cmd_match(CMD_IF_C_OR_CPP)) { /* %* for C and C++ */ - sko_push(do_copy); + sko_push(do_copy); do_copy = true; - } - else if (cmd_match (CMD_NOT_FOR_HEADER)) { + } else if (cmd_match(CMD_NOT_FOR_HEADER)) { /* %c begin linkage-only (non-header) code. */ - OUT_BEGIN_CODE (); - } - else if (cmd_match (CMD_OK_FOR_HEADER)) { + OUT_BEGIN_CODE(); + } else if (cmd_match(CMD_OK_FOR_HEADER)) { /* %e end linkage-only code. */ - OUT_END_CODE (); - } - else if (buf[1] == '#') { + OUT_END_CODE(); + } else if (buf[1] == '#') { /* %# a comment in the skel. ignore. */ + } else { + flexfatal(_("bad line in skeleton file")); } - else { - flexfatal (_("bad line in skeleton file")); - } - } - - else if (do_copy) - outn (buf); + } else if (do_copy) + outn(buf); } /* end while */ } @@ -946,23 +968,24 @@ * element_n. Formats the output with spaces and carriage returns. */ -void transition_struct_out (element_v, element_n) - int element_v, element_n; +void +transition_struct_out(element_v, element_n) + int element_v, element_n; { /* short circuit any output */ if (!gentables) return; - out_dec2 (" {%4d,%4d },", element_v, element_n); + out_dec2(" {%4d,%4d },", element_v, element_n); datapos += TRANS_STRUCT_PRINT_LENGTH; if (datapos >= 79 - TRANS_STRUCT_PRINT_LENGTH) { - outc ('\n'); + outc('\n'); if (++dataline % 10 == 0) - outc ('\n'); + outc('\n'); datapos = 0; } @@ -972,14 +995,15 @@ /* The following is only needed when building flex's parser using certain * broken versions of bison. */ -void *yy_flex_xmalloc (size) - int size; +void * +yy_flex_xmalloc(size) + int size; { - void *result = flex_alloc ((size_t) size); + void *result = flex_alloc((size_t) size); if (!result) - flexfatal (_ - ("memory allocation failed in yy_flex_xmalloc()")); + flexfatal(_ + ("memory allocation failed in yy_flex_xmalloc()")); return result; } @@ -990,9 +1014,10 @@ * Sets region_ptr[0] through region_ptr[size_in_bytes - 1] to zero. */ -void zero_out (region_ptr, size_in_bytes) - char *region_ptr; - size_t size_in_bytes; +void +zero_out(region_ptr, size_in_bytes) + char *region_ptr; + size_t size_in_bytes; { char *rp, *rp_end; @@ -1006,10 +1031,11 @@ /* Remove all '\n' and '\r' characters, if any, from the end of str. * str can be any null-terminated string, or NULL. * returns str. */ -char *chomp (str) - char *str; +char * +chomp(str) + char *str; { - char *p = str; + char *p = str; if (!str || !*str) /* s is null or empty string */ return str;