contrib/flex/src/misc.c

   1 /* misc - miscellaneous flex routines */
   2
   3 /*  Copyright (c) 1990 The Regents of the University of California. */
   4 /*  All rights reserved. */
   5
   6 /*  This code is derived from software contributed to Berkeley by */
   7 /*  Vern Paxson. */
   8
   9 /*  The United States Government has rights in this work pursuant */
  10 /*  to contract no. DE-AC03-76SF00098 between the United States */
  11 /*  Department of Energy and the University of California. */
  12
  13 /*  This file is part of flex. */
  14
  15 /*  Redistribution and use in source and binary forms, with or without */
  16 /*  modification, are permitted provided that the following conditions */
  17 /*  are met: */
  18
  19 /*  1. Redistributions of source code must retain the above copyright */
  20 /*     notice, this list of conditions and the following disclaimer. */
  21 /*  2. Redistributions in binary form must reproduce the above copyright */
  22 /*     notice, this list of conditions and the following disclaimer in the */
  23 /*     documentation and/or other materials provided with the distribution. */
  24
  25 /*  Neither the name of the University nor the names of its contributors */
  26 /*  may be used to endorse or promote products derived from this software */
  27 /*  without specific prior written permission. */
  28
  29 /*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
  30 /*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
  31 /*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
  32 /*  PURPOSE. */
  33 #include "flexdef.h"
  34 #include "tables.h"
  35
  36 #define CMD_IF_TABLES_SER    "%if-tables-serialization"
  37 #define CMD_TABLES_YYDMAP    "%tables-yydmap"
  38 #define CMD_DEFINE_YYTABLES  "%define-yytables"
  39 #define CMD_IF_CPP_ONLY      "%if-c++-only"
  40 #define CMD_IF_C_ONLY        "%if-c-only"
  41 #define CMD_IF_C_OR_CPP      "%if-c-or-c++"
  42 #define CMD_NOT_FOR_HEADER   "%not-for-header"
  43 #define CMD_OK_FOR_HEADER    "%ok-for-header"
  44 #define CMD_PUSH             "%push"
  45 #define CMD_POP              "%pop"
  46 #define CMD_IF_REENTRANT     "%if-reentrant"
  47 #define CMD_IF_NOT_REENTRANT "%if-not-reentrant"
  48 #define CMD_IF_BISON_BRIDGE  "%if-bison-bridge"
  49 #define CMD_IF_NOT_BISON_BRIDGE  "%if-not-bison-bridge"
  50 #define CMD_ENDIF            "%endif"
  51
  52 /* we allow the skeleton to push and pop. */
  53 struct sko_state {
  54     bool dc; /**< do_copy */
  55 };
  56 static struct sko_state *sko_stack=0;
  57 static int sko_len=0,sko_sz=0;
  58 static void sko_push(bool dc)
  59 {
  60     if(!sko_stack){
  61         sko_sz = 1;
  62         sko_stack = malloc(sizeof(struct sko_state) * (size_t) sko_sz);
  63         if (!sko_stack)
  64             flexfatal(_("allocation of sko_stack failed"));
  65         sko_len = 0;
  66     }
  67     if(sko_len >= sko_sz){
  68         sko_sz *= 2;
  69         sko_stack = realloc(sko_stack,
  70                         sizeof(struct sko_state) * (size_t) sko_sz);
  71     }
  72
  73     /* initialize to zero and push */
  74     sko_stack[sko_len].dc = dc;
  75     sko_len++;
  76 }
  77 static void sko_peek(bool *dc)
  78 {
  79     if(sko_len <= 0)
  80         flex_die("peek attempt when sko stack is empty");
  81     if(dc)
  82         *dc = sko_stack[sko_len-1].dc;
  83 }
  84 static void sko_pop(bool* dc)
  85 {
  86     sko_peek(dc);
  87     sko_len--;
  88     if(sko_len < 0)
  89         flex_die("popped too many times in skeleton.");
  90 }
  91
  92 /* Append "#define defname value\n" to the running buffer. */
  93 void action_define (const char *defname, int value)
  94 {
  95         char    buf[MAXLINE];
  96         char   *cpy;
  97
  98         if ((int) strlen (defname) > MAXLINE / 2) {
  99                 format_pinpoint_message (_
 100                                          ("name \"%s\" ridiculously long"),
 101                                          defname);
 102                 return;
 103         }
 104
 105         snprintf (buf, sizeof(buf), "#define %s %d\n", defname, value);
 106         add_action (buf);
 107
 108         /* track #defines so we can undef them when we're done. */
 109         cpy = xstrdup(defname);
 110         buf_append (&defs_buf, &cpy, 1);
 111 }
 112
 113 /* Append "new_text" to the running buffer. */
 114 void add_action (const char *new_text)
 115 {
 116         int     len = (int) strlen (new_text);
 117
 118         while (len + action_index >= action_size - 10 /* slop */ ) {
 119                 int     new_size = action_size * 2;
 120
 121                 if (new_size <= 0)
 122                         /* Increase just a little, to try to avoid overflow
 123                          * on 16-bit machines.
 124                          */
 125                         action_size += action_size / 8;
 126                 else
 127                         action_size = new_size;
 128
 129                 action_array =
 130                         reallocate_character_array (action_array,
 131                                                     action_size);
 132         }
 133
 134         strcpy (&action_array[action_index], new_text);
 135
 136         action_index += len;
 137 }
 138
 139
 140 /* allocate_array - allocate memory for an integer array of the given size */
 141
 142 void   *allocate_array (int size, size_t element_size)
 143 {
 144         void *mem;
 145 #if HAVE_REALLOCARRAY
 146         /* reallocarray has built-in overflow detection */
 147         mem = reallocarray(NULL, (size_t) size, element_size);
 148 #else
 149         size_t num_bytes = (size_t) size * element_size;
 150         mem = (size && SIZE_MAX / (size_t) size < element_size) ? NULL :
 151                 malloc(num_bytes);
 152 #endif
 153         if (!mem)
 154                 flexfatal (_
 155                            ("memory allocation failed in allocate_array()"));
 156
 157         return mem;
 158 }
 159
 160
 161 /* all_lower - true if a string is all lower-case */
 162
 163 int all_lower (char *str)
 164 {
 165         while (*str) {
 166                 if (!isascii ((unsigned char) * str) || !islower ((unsigned char) * str))
 167                         return 0;
 168                 ++str;
 169         }
 170
 171         return 1;
 172 }
 173
 174
 175 /* all_upper - true if a string is all upper-case */
 176
 177 int all_upper (char *str)
 178 {
 179         while (*str) {
 180                 if (!isascii ((unsigned char) * str) || !isupper ((unsigned char) * str))
 181                         return 0;
 182                 ++str;
 183         }
 184
 185         return 1;
 186 }
 187
 188
 189 /* intcmp - compares two integers for use by qsort. */
 190
 191 int intcmp (const void *a, const void *b)
 192 {
 193   return *(const int *) a - *(const int *) b;
 194 }
 195
 196
 197 /* check_char - checks a character to make sure it's within the range
 198  *              we're expecting.  If not, generates fatal error message
 199  *              and exits.
 200  */
 201
 202 void check_char (int c)
 203 {
 204         if (c >= CSIZE)
 205                 lerr (_("bad character '%s' detected in check_char()"),
 206                         readable_form (c));
 207
 208         if (c >= csize)
 209                 lerr (_
 210                         ("scanner requires -8 flag to use the character %s"),
 211                         readable_form (c));
 212 }
 213
 214
 215
 216 /* clower - replace upper-case letter to lower-case */
 217
 218 unsigned char clower (int c)
 219 {
 220         return (unsigned char) ((isascii (c) && isupper (c)) ? tolower (c) : c);
 221 }
 222
 223
 224 char *xstrdup(const char *s)
 225 {
 226         char *s2;
 227
 228         if ((s2 = strdup(s)) == NULL)
 229                 flexfatal (_("memory allocation failure in xstrdup()"));
 230
 231         return s2;
 232 }
 233
 234
 235 /* cclcmp - compares two characters for use by qsort with '\0' sorting last. */
 236
 237 int cclcmp (const void *a, const void *b)
 238 {
 239   if (!*(const unsigned char *) a)
 240         return 1;
 241   else
 242         if (!*(const unsigned char *) b)
 243           return - 1;
 244         else
 245           return *(const unsigned char *) a - *(const unsigned char *) b;
 246 }
 247
 248
 249 /* dataend - finish up a block of data declarations */
 250
 251 void dataend (void)
 252 {
 253         /* short circuit any output */
 254         if (gentables) {
 255
 256                 if (datapos > 0)
 257                         dataflush ();
 258
 259                 /* add terminator for initialization; { for vi */
 260                 outn ("    } ;\n");
 261         }
 262         dataline = 0;
 263         datapos = 0;
 264 }
 265
 266
 267 /* dataflush - flush generated data statements */
 268
 269 void dataflush (void)
 270 {
 271         /* short circuit any output */
 272         if (!gentables)
 273                 return;
 274
 275         outc ('\n');
 276
 277         if (++dataline >= NUMDATALINES) {
 278                 /* Put out a blank line so that the table is grouped into
 279                  * large blocks that enable the user to find elements easily.
 280                  */
 281                 outc ('\n');
 282                 dataline = 0;
 283         }
 284
 285         /* Reset the number of characters written on the current line. */
 286         datapos = 0;
 287 }
 288
 289
 290 /* flexerror - report an error message and terminate */
 291
 292 void flexerror (const char *msg)
 293 {
 294         fprintf (stderr, "%s: %s\n", program_name, msg);
 295         flexend (1);
 296 }
 297
 298
 299 /* flexfatal - report a fatal error message and terminate */
 300
 301 void flexfatal (const char *msg)
 302 {
 303         fprintf (stderr, _("%s: fatal internal error, %s\n"),
 304                  program_name, msg);
 305         FLEX_EXIT (1);
 306 }
 307
 308
 309 /* lerr - report an error message */
 310
 311 void lerr (const char *msg, ...)
 312 {
 313         char    errmsg[MAXLINE];
 314         va_list args;
 315
 316         va_start(args, msg);
 317         vsnprintf (errmsg, sizeof(errmsg), msg, args);
 318         va_end(args);
 319         flexerror (errmsg);
 320 }
 321
 322
 323 /* lerr_fatal - as lerr, but call flexfatal */
 324
 325 void lerr_fatal (const char *msg, ...)
 326 {
 327         char    errmsg[MAXLINE];
 328         va_list args;
 329         va_start(args, msg);
 330
 331         vsnprintf (errmsg, sizeof(errmsg), msg, args);
 332         va_end(args);
 333         flexfatal (errmsg);
 334 }
 335
 336
 337 /* line_directive_out - spit out a "#line" statement */
 338
 339 void line_directive_out (FILE *output_file, int do_infile)
 340 {
 341         char    directive[MAXLINE], filename[MAXLINE];
 342         char   *s1, *s2, *s3;
 343         static const char line_fmt[] = "#line %d \"%s\"\n";
 344
 345         if (!gen_line_dirs)
 346                 return;
 347
 348         s1 = do_infile ? infilename : "M4_YY_OUTFILE_NAME";
 349
 350         if (do_infile && !s1)
 351         s1 = "<stdin>";
 352
 353         s2 = filename;
 354         s3 = &filename[sizeof (filename) - 2];
 355
 356         while (s2 < s3 && *s1) {
 357                 if (*s1 == '\\' || *s1 == '"')
 358                         /* Escape the '\' or '"' */
 359                         *s2++ = '\\';
 360
 361                 *s2++ = *s1++;
 362         }
 363
 364         *s2 = '\0';
 365
 366         if (do_infile)
 367                 snprintf (directive, sizeof(directive), line_fmt, linenum, filename);
 368         else {
 369                 snprintf (directive, sizeof(directive), line_fmt, 0, filename);
 370         }
 371
 372         /* If output_file is nil then we should put the directive in
 373          * the accumulated actions.
 374          */
 375         if (output_file) {
 376                 fputs (directive, output_file);
 377         }
 378         else
 379                 add_action (directive);
 380 }
 381
 382
 383 /* mark_defs1 - mark the current position in the action array as
 384  *               representing where the user's section 1 definitions end
 385  *               and the prolog begins
 386  */
 387 void mark_defs1 (void)
 388 {
 389         defs1_offset = 0;
 390         action_array[action_index++] = '\0';
 391         action_offset = prolog_offset = action_index;
 392         action_array[action_index] = '\0';
 393 }
 394
 395
 396 /* mark_prolog - mark the current position in the action array as
 397  *               representing the end of the action prolog
 398  */
 399 void mark_prolog (void)
 400 {
 401         action_array[action_index++] = '\0';
 402         action_offset = action_index;
 403         action_array[action_index] = '\0';
 404 }
 405
 406
 407 /* mk2data - generate a data statement for a two-dimensional array
 408  *
 409  * Generates a data statement initializing the current 2-D array to "value".
 410  */
 411 void mk2data (int value)
 412 {
 413         /* short circuit any output */
 414         if (!gentables)
 415                 return;
 416
 417         if (datapos >= NUMDATAITEMS) {
 418                 outc (',');
 419                 dataflush ();
 420         }
 421
 422         if (datapos == 0)
 423                 /* Indent. */
 424                 out ("    ");
 425
 426         else
 427                 outc (',');
 428
 429         ++datapos;
 430
 431         out_dec ("%5d", value);
 432 }
 433
 434
 435 /* mkdata - generate a data statement
 436  *
 437  * Generates a data statement initializing the current array element to
 438  * "value".
 439  */
 440 void mkdata (int value)
 441 {
 442         /* short circuit any output */
 443         if (!gentables)
 444                 return;
 445
 446         if (datapos >= NUMDATAITEMS) {
 447                 outc (',');
 448                 dataflush ();
 449         }
 450
 451         if (datapos == 0)
 452                 /* Indent. */
 453                 out ("    ");
 454         else
 455                 outc (',');
 456
 457         ++datapos;
 458
 459         out_dec ("%5d", value);
 460 }
 461
 462
 463 /* myctoi - return the integer represented by a string of digits */
 464
 465 int myctoi (const char *array)
 466 {
 467         int     val = 0;
 468
 469         (void) sscanf (array, "%d", &val);
 470
 471         return val;
 472 }
 473
 474
 475 /* myesc - return character corresponding to escape sequence */
 476
 477 unsigned char myesc (unsigned char array[])
 478 {
 479         unsigned char    c, esc_char;
 480
 481         switch (array[1]) {
 482         case 'b':
 483                 return '\b';
 484         case 'f':
 485                 return '\f';
 486         case 'n':
 487                 return '\n';
 488         case 'r':
 489                 return '\r';
 490         case 't':
 491                 return '\t';
 492         case 'a':
 493                 return '\a';
 494         case 'v':
 495                 return '\v';
 496         case '0':
 497         case '1':
 498         case '2':
 499         case '3':
 500         case '4':
 501         case '5':
 502         case '6':
 503         case '7':
 504                 {               /* \<octal> */
 505                         int     sptr = 1;
 506
 507                         while (sptr <= 3 &&
 508                                array[sptr] >= '0' && array[sptr] <= '7') {
 509                                 ++sptr;
 510                         }
 511
 512                         c = array[sptr];
 513                         array[sptr] = '\0';
 514
 515                         esc_char = (unsigned char) strtoul (array + 1, NULL, 8);
 516
 517                         array[sptr] = c;
 518
 519                         return esc_char;
 520                 }
 521
 522         case 'x':
 523                 {               /* \x<hex> */
 524                         int     sptr = 2;
 525
 526                         while (sptr <= 3 && isxdigit (array[sptr])) {
 527                                 /* Don't increment inside loop control
 528                                  * because if isxdigit() is a macro it might
 529                                  * expand into multiple increments ...
 530                                  */
 531                                 ++sptr;
 532                         }
 533
 534                         c = array[sptr];
 535                         array[sptr] = '\0';
 536
 537                         esc_char = (unsigned char) strtoul (array + 2, NULL, 16);
 538
 539                         array[sptr] = c;
 540
 541                         return esc_char;
 542                 }
 543
 544         default:
 545                 return array[1];
 546         }
 547 }
 548
 549
 550 /* out - various flavors of outputing a (possibly formatted) string for the
 551  *       generated scanner, keeping track of the line count.
 552  */
 553
 554 void out (const char *str)
 555 {
 556         fputs (str, stdout);
 557 }
 558
 559 void out_dec (const char *fmt, int n)
 560 {
 561         fprintf (stdout, fmt, n);
 562 }
 563
 564 void out_dec2 (const char *fmt, int n1, int n2)
 565 {
 566         fprintf (stdout, fmt, n1, n2);
 567 }
 568
 569 void out_hex (const char *fmt, unsigned int x)
 570 {
 571         fprintf (stdout, fmt, x);
 572 }
 573
 574 void out_str (const char *fmt, const char str[])
 575 {
 576         fprintf (stdout,fmt, str);
 577 }
 578
 579 void out_str3 (const char *fmt, const char s1[], const char s2[], const char s3[])
 580 {
 581         fprintf (stdout,fmt, s1, s2, s3);
 582 }
 583
 584 void out_str_dec (const char *fmt, const char str[], int n)
 585 {
 586         fprintf (stdout,fmt, str, n);
 587 }
 588
 589 void outc (int c)
 590 {
 591         fputc (c, stdout);
 592 }
 593
 594 void outn (const char *str)
 595 {
 596         fputs (str,stdout);
 597     fputc('\n',stdout);
 598 }
 599
 600 /** Print "m4_define( [[def]], [[val]])m4_dnl\n".
 601  * @param def The m4 symbol to define.
 602  * @param val The definition; may be NULL.
 603  */
 604 void out_m4_define (const char* def, const char* val)
 605 {
 606     const char * fmt = "m4_define( [[%s]], [[%s]])m4_dnl\n";
 607     fprintf(stdout, fmt, def, val?val:"");
 608 }
 609
 610
 611 /* readable_form - return the the human-readable form of a character
 612  *
 613  * The returned string is in static storage.
 614  */
 615
 616 char   *readable_form (int c)
 617 {
 618         static char rform[20];
 619
 620         if ((c >= 0 && c < 32) || c >= 127) {
 621                 switch (c) {
 622                 case '\b':
 623                         return "\\b";
 624                 case '\f':
 625                         return "\\f";
 626                 case '\n':
 627                         return "\\n";
 628                 case '\r':
 629                         return "\\r";
 630                 case '\t':
 631                         return "\\t";
 632                 case '\a':
 633                         return "\\a";
 634                 case '\v':
 635                         return "\\v";
 636                 default:
 637                         if(trace_hex)
 638                                 snprintf (rform, sizeof(rform), "\\x%.2x", (unsigned int) c);
 639                         else
 640                                 snprintf (rform, sizeof(rform), "\\%.3o", (unsigned int) c);
 641                         return rform;
 642                 }
 643         }
 644
 645         else if (c == ' ')
 646                 return "' '";
 647
 648         else {
 649                 rform[0] = (char) c;
 650                 rform[1] = '\0';
 651
 652                 return rform;
 653         }
 654 }
 655
 656
 657 /* reallocate_array - increase the size of a dynamic array */
 658
 659 void   *reallocate_array (void *array, int size, size_t element_size)
 660 {
 661         void *new_array;
 662 #if HAVE_REALLOCARRAY
 663         /* reallocarray has built-in overflow detection */
 664         new_array = reallocarray(array, (size_t) size, element_size);
 665 #else
 666         size_t num_bytes = (size_t) size * element_size;
 667         new_array = (size && SIZE_MAX / (size_t) size < element_size) ? NULL :
 668                 realloc(array, num_bytes);
 669 #endif
 670         if (!new_array)
 671                 flexfatal (_("attempt to increase array size failed"));
 672
 673         return new_array;
 674 }
 675
 676
 677 /* skelout - write out one section of the skeleton file
 678  *
 679  * Description
 680  *    Copies skelfile or skel array to stdout until a line beginning with
 681  *    "%%" or EOF is found.
 682  */
 683 void skelout (void)
 684 {
 685         char    buf_storage[MAXLINE];
 686         char   *buf = buf_storage;
 687         bool   do_copy = true;
 688
 689     /* "reset" the state by clearing the buffer and pushing a '1' */
 690     if(sko_len > 0)
 691         sko_peek(&do_copy);
 692     sko_len = 0;
 693     sko_push(do_copy=true);
 694
 695
 696         /* Loop pulling lines either from the skelfile, if we're using
 697          * one, or from the skel[] array.
 698          */
 699         while (skelfile ?
 700                (fgets (buf, MAXLINE, skelfile) != NULL) :
 701                ((buf = (char *) skel[skel_ind++]) != 0)) {
 702
 703                 if (skelfile)
 704                         chomp (buf);
 705
 706                 /* copy from skel array */
 707                 if (buf[0] == '%') {    /* control line */
 708                         /* print the control line as a comment. */
 709                         if (ddebug && buf[1] != '#') {
 710                                 if (buf[strlen (buf) - 1] == '\\')
 711                                         out_str ("/* %s */\\\n", buf);
 712                                 else
 713                                         out_str ("/* %s */\n", buf);
 714                         }
 715
 716                         /* We've been accused of using cryptic markers in the skel.
 717                          * So we'll use emacs-style-hyphenated-commands.
 718              * We might consider a hash if this if-else-if-else
 719              * chain gets too large.
 720                          */
 721 #define cmd_match(s) (strncmp(buf,(s),strlen(s))==0)
 722
 723                         if (buf[1] == '%') {
 724                                 /* %% is a break point for skelout() */
 725                                 return;
 726                         }
 727             else if (cmd_match (CMD_PUSH)){
 728                 sko_push(do_copy);
 729                 if(ddebug){
 730                     out_str("/*(state = (%s) */",do_copy?"true":"false");
 731                 }
 732                 out_str("%s\n", buf[strlen (buf) - 1] =='\\' ? "\\" : "");
 733             }
 734             else if (cmd_match (CMD_POP)){
 735                 sko_pop(&do_copy);
 736                 if(ddebug){
 737                     out_str("/*(state = (%s) */",do_copy?"true":"false");
 738                 }
 739                 out_str("%s\n", buf[strlen (buf) - 1] =='\\' ? "\\" : "");
 740             }
 741             else if (cmd_match (CMD_IF_REENTRANT)){
 742                 sko_push(do_copy);
 743                 do_copy = reentrant && do_copy;
 744             }
 745             else if (cmd_match (CMD_IF_NOT_REENTRANT)){
 746                 sko_push(do_copy);
 747                 do_copy = !reentrant && do_copy;
 748             }
 749             else if (cmd_match(CMD_IF_BISON_BRIDGE)){
 750                 sko_push(do_copy);
 751                 do_copy = bison_bridge_lval && do_copy;
 752             }
 753             else if (cmd_match(CMD_IF_NOT_BISON_BRIDGE)){
 754                 sko_push(do_copy);
 755                 do_copy = !bison_bridge_lval && do_copy;
 756             }
 757             else if (cmd_match (CMD_ENDIF)){
 758                 sko_pop(&do_copy);
 759             }
 760                         else if (cmd_match (CMD_IF_TABLES_SER)) {
 761                 do_copy = do_copy && tablesext;
 762                         }
 763                         else if (cmd_match (CMD_TABLES_YYDMAP)) {
 764                                 if (tablesext && yydmap_buf.elts)
 765                                         outn ((char *) (yydmap_buf.elts));
 766                         }
 767             else if (cmd_match (CMD_DEFINE_YYTABLES)) {
 768                 out_str("#define YYTABLES_NAME \"%s\"\n",
 769                         tablesname?tablesname:"yytables");
 770             }
 771                         else if (cmd_match (CMD_IF_CPP_ONLY)) {
 772                                 /* only for C++ */
 773                 sko_push(do_copy);
 774                                 do_copy = C_plus_plus;
 775                         }
 776                         else if (cmd_match (CMD_IF_C_ONLY)) {
 777                                 /* %- only for C */
 778                 sko_push(do_copy);
 779                                 do_copy = !C_plus_plus;
 780                         }
 781                         else if (cmd_match (CMD_IF_C_OR_CPP)) {
 782                                 /* %* for C and C++ */
 783                 sko_push(do_copy);
 784                                 do_copy = true;
 785                         }
 786                         else if (cmd_match (CMD_NOT_FOR_HEADER)) {
 787                                 /* %c begin linkage-only (non-header) code. */
 788                                 OUT_BEGIN_CODE ();
 789                         }
 790                         else if (cmd_match (CMD_OK_FOR_HEADER)) {
 791                                 /* %e end linkage-only code. */
 792                                 OUT_END_CODE ();
 793                         }
 794                         else {
 795                                 flexfatal (_("bad line in skeleton file"));
 796                         }
 797                 }
 798
 799                 else if (do_copy)
 800             outn (buf);
 801         }                       /* end while */
 802 }
 803
 804
 805 /* transition_struct_out - output a yy_trans_info structure
 806  *
 807  * outputs the yy_trans_info structure with the two elements, element_v and
 808  * element_n.  Formats the output with spaces and carriage returns.
 809  */
 810
 811 void transition_struct_out (int element_v, int element_n)
 812 {
 813
 814         /* short circuit any output */
 815         if (!gentables)
 816                 return;
 817
 818         out_dec2 (" {%4d,%4d },", element_v, element_n);
 819
 820         datapos += TRANS_STRUCT_PRINT_LENGTH;
 821
 822         if (datapos >= 79 - TRANS_STRUCT_PRINT_LENGTH) {
 823                 outc ('\n');
 824
 825                 if (++dataline % 10 == 0)
 826                         outc ('\n');
 827
 828                 datapos = 0;
 829         }
 830 }
 831
 832
 833 /* The following is only needed when building flex's parser using certain
 834  * broken versions of bison.
 835  *
 836  * XXX: this is should go soon
 837  */
 838 void   *yy_flex_xmalloc (int size)
 839 {
 840         void   *result;
 841
 842         result = malloc((size_t) size);
 843         if (!result)
 844                 flexfatal (_
 845                            ("memory allocation failed in yy_flex_xmalloc()"));
 846
 847         return result;
 848 }
 849
 850
 851 /* Remove all '\n' and '\r' characters, if any, from the end of str.
 852  * str can be any null-terminated string, or NULL.
 853  * returns str. */
 854 char   *chomp (char *str)
 855 {
 856         char   *p = str;
 857
 858         if (!str || !*str)      /* s is null or empty string */
 859                 return str;
 860
 861         /* find end of string minus one */
 862         while (*p)
 863                 ++p;
 864         --p;
 865
 866         /* eat newlines */
 867         while (p >= str && (*p == '\r' || *p == '\n'))
 868                 *p-- = 0;
 869         return str;
 870 }