usr.bin/m4/manual_tokenizer.c

   1
   2 #line 3 "<stdout>"
   3
   4 #define  YY_INT_ALIGNED short int
   5
   6 /* A lexical scanner generated by flex */
   7
   8 #define FLEX_SCANNER
   9 #define YY_FLEX_MAJOR_VERSION FLEX_MAJOR_VERSION
  10 #define YY_FLEX_MINOR_VERSION FLEX_MINOR_VERSION
  11 #define YY_FLEX_SUBMINOR_VERSION FLEX_SUBMINOR_VERSION
  12 #if YY_FLEX_SUBMINOR_VERSION > 0
  13 #define FLEX_BETA
  14 #endif
  15
  16 /* First, we deal with  platform-specific or compiler-specific issues. */
  17
  18 /* begin standard C headers. */
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <errno.h>
  22 #include <stdlib.h>
  23
  24 /* end standard C headers. */
  25
  26 /* flex integer type definitions */
  27
  28 #ifndef FLEXINT_H
  29 #define FLEXINT_H
  30
  31 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  32
  33 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  34
  35 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  36  * if you want the limit (max/min) macros for int types.
  37  */
  38 #ifndef __STDC_LIMIT_MACROS
  39 #define __STDC_LIMIT_MACROS 1
  40 #endif
  41
  42 #include <inttypes.h>
  43 typedef int8_t flex_int8_t;
  44 typedef uint8_t flex_uint8_t;
  45 typedef int16_t flex_int16_t;
  46 typedef uint16_t flex_uint16_t;
  47 typedef int32_t flex_int32_t;
  48 typedef uint32_t flex_uint32_t;
  49 #else
  50 typedef signed char flex_int8_t;
  51 typedef short int flex_int16_t;
  52 typedef int flex_int32_t;
  53 typedef unsigned char flex_uint8_t;
  54 typedef unsigned short int flex_uint16_t;
  55 typedef unsigned int flex_uint32_t;
  56
  57 /* Limits of integral types. */
  58 #ifndef INT8_MIN
  59 #define INT8_MIN               (-128)
  60 #endif
  61 #ifndef INT16_MIN
  62 #define INT16_MIN              (-32767-1)
  63 #endif
  64 #ifndef INT32_MIN
  65 #define INT32_MIN              (-2147483647-1)
  66 #endif
  67 #ifndef INT8_MAX
  68 #define INT8_MAX               (127)
  69 #endif
  70 #ifndef INT16_MAX
  71 #define INT16_MAX              (32767)
  72 #endif
  73 #ifndef INT32_MAX
  74 #define INT32_MAX              (2147483647)
  75 #endif
  76 #ifndef UINT8_MAX
  77 #define UINT8_MAX              (255U)
  78 #endif
  79 #ifndef UINT16_MAX
  80 #define UINT16_MAX             (65535U)
  81 #endif
  82 #ifndef UINT32_MAX
  83 #define UINT32_MAX             (4294967295U)
  84 #endif
  85
  86 #endif /* ! C99 */
  87
  88 #endif /* ! FLEXINT_H */
  89
  90 #ifdef __cplusplus
  91
  92 /* The "const" storage-class-modifier is valid. */
  93 #define YY_USE_CONST
  94
  95 #else   /* ! __cplusplus */
  96
  97 /* C99 requires __STDC__ to be defined as 1. */
  98 #if defined (__STDC__)
  99
 100 #define YY_USE_CONST
 101
 102 #endif  /* defined (__STDC__) */
 103 #endif  /* ! __cplusplus */
 104
 105 #ifdef YY_USE_CONST
 106 #define yyconst const
 107 #else
 108 #define yyconst
 109 #endif
 110
 111 /* Returned upon end-of-file. */
 112 #define YY_NULL 0
 113
 114 /* Promotes a possibly negative, possibly signed char to an unsigned
 115  * integer for use as an array index.  If the signed char is negative,
 116  * we want to instead treat it as an 8-bit unsigned char, hence the
 117  * double cast.
 118  */
 119 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 120
 121 /* Enter a start condition.  This macro really ought to take a parameter,
 122  * but we do it the disgusting crufty way forced on us by the ()-less
 123  * definition of BEGIN.
 124  */
 125 #define BEGIN (yy_start) = 1 + 2 *
 126
 127 /* Translate the current start state into a value that can be later handed
 128  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 129  * compatibility.
 130  */
 131 #define YY_START (((yy_start) - 1) / 2)
 132 #define YYSTATE YY_START
 133
 134 /* Action number for EOF rule of a given start state. */
 135 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 136
 137 /* Special action meaning "start processing a new file". */
 138 #define YY_NEW_FILE yyrestart(yyin  )
 139
 140 #define YY_END_OF_BUFFER_CHAR 0
 141
 142 /* Size of default input buffer. */
 143 #ifndef YY_BUF_SIZE
 144 #define YY_BUF_SIZE 16384
 145 #endif
 146
 147 /* The state buf must be large enough to hold one state per character in the main buffer.
 148  */
 149 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 150
 151 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 152 #define YY_TYPEDEF_YY_BUFFER_STATE
 153 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 154 #endif
 155
 156 #ifndef YY_TYPEDEF_YY_SIZE_T
 157 #define YY_TYPEDEF_YY_SIZE_T
 158 typedef size_t yy_size_t;
 159 #endif
 160
 161 extern yy_size_t yyleng;
 162
 163 extern FILE *yyin, *yyout;
 164
 165 #define EOB_ACT_CONTINUE_SCAN 0
 166 #define EOB_ACT_END_OF_FILE 1
 167 #define EOB_ACT_LAST_MATCH 2
 168
 169     #define YY_LESS_LINENO(n)
 170
 171 /* Return all but the first "n" matched characters back to the input stream. */
 172 #define yyless(n) \
 173         do \
 174                 { \
 175                 /* Undo effects of setting up yytext. */ \
 176         int yyless_macro_arg = (n); \
 177         YY_LESS_LINENO(yyless_macro_arg);\
 178                 *yy_cp = (yy_hold_char); \
 179                 YY_RESTORE_YY_MORE_OFFSET \
 180                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 181                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 182                 } \
 183         while ( 0 )
 184
 185 #define unput(c) yyunput( c, (yytext_ptr)  )
 186
 187 #ifndef YY_STRUCT_YY_BUFFER_STATE
 188 #define YY_STRUCT_YY_BUFFER_STATE
 189 struct yy_buffer_state
 190         {
 191         FILE *yy_input_file;
 192
 193         char *yy_ch_buf;                /* input buffer */
 194         char *yy_buf_pos;               /* current position in input buffer */
 195
 196         /* Size of input buffer in bytes, not including room for EOB
 197          * characters.
 198          */
 199         yy_size_t yy_buf_size;
 200
 201         /* Number of characters read into yy_ch_buf, not including EOB
 202          * characters.
 203          */
 204         yy_size_t yy_n_chars;
 205
 206         /* Whether we "own" the buffer - i.e., we know we created it,
 207          * and can realloc() it to grow it, and should free() it to
 208          * delete it.
 209          */
 210         int yy_is_our_buffer;
 211
 212         /* Whether this is an "interactive" input source; if so, and
 213          * if we're using stdio for input, then we want to use getc()
 214          * instead of fread(), to make sure we stop fetching input after
 215          * each newline.
 216          */
 217         int yy_is_interactive;
 218
 219         /* Whether we're considered to be at the beginning of a line.
 220          * If so, '^' rules will be active on the next match, otherwise
 221          * not.
 222          */
 223         int yy_at_bol;
 224
 225     int yy_bs_lineno; /**< The line count. */
 226     int yy_bs_column; /**< The column count. */
 227
 228         /* Whether to try to fill the input buffer when we reach the
 229          * end of it.
 230          */
 231         int yy_fill_buffer;
 232
 233         int yy_buffer_status;
 234
 235 #define YY_BUFFER_NEW 0
 236 #define YY_BUFFER_NORMAL 1
 237         /* When an EOF's been seen but there's still some text to process
 238          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 239          * shouldn't try reading from the input source any more.  We might
 240          * still have a bunch of tokens to match, though, because of
 241          * possible backing-up.
 242          *
 243          * When we actually see the EOF, we change the status to "new"
 244          * (via yyrestart()), so that the user can continue scanning by
 245          * just pointing yyin at a new input file.
 246          */
 247 #define YY_BUFFER_EOF_PENDING 2
 248
 249         };
 250 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 251
 252 /* Stack of input buffers. */
 253 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 254 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 255 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 256
 257 /* We provide macros for accessing buffer states in case in the
 258  * future we want to put the buffer states in a more general
 259  * "scanner state".
 260  *
 261  * Returns the top of the stack, or NULL.
 262  */
 263 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 264                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 265                           : NULL)
 266
 267 /* Same as previous macro, but useful when we know that the buffer stack is not
 268  * NULL or when we need an lvalue. For internal use only.
 269  */
 270 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 271
 272 /* yy_hold_char holds the character lost when yytext is formed. */
 273 static char yy_hold_char;
 274 static yy_size_t yy_n_chars;            /* number of characters read into yy_ch_buf */
 275 yy_size_t yyleng;
 276
 277 /* Points to current character in buffer. */
 278 static char *yy_c_buf_p = (char *) 0;
 279 static int yy_init = 0;         /* whether we need to initialize */
 280 static int yy_start = 0;        /* start state number */
 281
 282 /* Flag which is used to allow yywrap()'s to do buffer switches
 283  * instead of setting up a fresh yyin.  A bit of a hack ...
 284  */
 285 static int yy_did_buffer_switch_on_eof;
 286
 287 void yyrestart (FILE *input_file  );
 288 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 289 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
 290 void yy_delete_buffer (YY_BUFFER_STATE b  );
 291 void yy_flush_buffer (YY_BUFFER_STATE b  );
 292 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
 293 void yypop_buffer_state (void );
 294
 295 static void yyensure_buffer_stack (void );
 296 static void yy_load_buffer_state (void );
 297 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 298
 299 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
 300
 301 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 302 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
 303 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len  );
 304
 305 void *yyalloc (yy_size_t  );
 306 void *yyrealloc (void *,yy_size_t  );
 307 void yyfree (void *  );
 308
 309 #define yy_new_buffer yy_create_buffer
 310
 311 #define yy_set_interactive(is_interactive) \
 312         { \
 313         if ( ! YY_CURRENT_BUFFER ){ \
 314         yyensure_buffer_stack (); \
 315                 YY_CURRENT_BUFFER_LVALUE =    \
 316             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 317         } \
 318         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 319         }
 320
 321 #define yy_set_bol(at_bol) \
 322         { \
 323         if ( ! YY_CURRENT_BUFFER ){\
 324         yyensure_buffer_stack (); \
 325                 YY_CURRENT_BUFFER_LVALUE =    \
 326             yy_create_buffer(yyin,YY_BUF_SIZE ); \
 327         } \
 328         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 329         }
 330
 331 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 332
 333 /* Begin user sect3 */
 334
 335 typedef unsigned char YY_CHAR;
 336
 337 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 338
 339 typedef int yy_state_type;
 340
 341 extern int yylineno;
 342
 343 int yylineno = 1;
 344
 345 extern char *yytext;
 346 #define yytext_ptr yytext
 347
 348 static yy_state_type yy_get_previous_state (void );
 349 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 350 static int yy_get_next_buffer (void );
 351 static void yy_fatal_error (yyconst char msg[]  );
 352
 353 /* Done after the current pattern has been matched and before the
 354  * corresponding action - sets up yytext.
 355  */
 356 #define YY_DO_BEFORE_ACTION \
 357         (yytext_ptr) = yy_bp; \
 358         yyleng = (size_t) (yy_cp - yy_bp); \
 359         (yy_hold_char) = *yy_cp; \
 360         *yy_cp = '\0'; \
 361         (yy_c_buf_p) = yy_cp;
 362
 363 #define YY_NUM_RULES 14
 364 #define YY_END_OF_BUFFER 15
 365 /* This struct is not used in this scanner,
 366    but its presence is necessary. */
 367 struct yy_trans_info
 368         {
 369         flex_int32_t yy_verify;
 370         flex_int32_t yy_nxt;
 371         };
 372 static yyconst flex_int16_t yy_accept[35] =
 373     {   0,
 374         0,    0,   15,   13,    1,    1,   13,   13,   13,    2,
 375         2,   13,   13,   13,   13,    1,    9,   10,   12,    2,
 376         0,    0,    2,    6,    4,    8,    5,    7,   11,    0,
 377         2,    0,    3,    0
 378     } ;
 379
 380 static yyconst flex_int32_t yy_ec[256] =
 381     {   0,
 382         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 383         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 384         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 385         1,    2,    4,    1,    1,    1,    1,    5,    1,    1,
 386         1,    6,    1,    1,    1,    1,    1,    7,    8,    8,
 387         8,    8,    8,    8,    8,    9,    9,   10,    1,   11,
 388        12,   13,    1,    1,   14,   14,   14,   14,   14,   14,
 389        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
 390        15,   16,   15,   15,   15,   15,   15,   17,   15,   15,
 391         1,    1,    1,    1,    1,    1,   14,   14,   14,   14,
 392
 393        14,   14,   15,   15,   15,   15,   15,   15,   15,   15,
 394        15,   15,   15,   16,   15,   15,   15,   15,   15,   17,
 395        15,   15,    1,   18,    1,    1,    1,    1,    1,    1,
 396         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 397         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 398         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 399         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 400         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 401         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 402         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 403
 404         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 405         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 406         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 407         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 408         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 409         1,    1,    1,    1,    1
 410     } ;
 411
 412 static yyconst flex_int32_t yy_meta[19] =
 413     {   0,
 414         1,    1,    1,    1,    1,    1,    2,    2,    2,    1,
 415         1,    1,    1,    3,    4,    4,    4,    1
 416     } ;
 417
 418 static yyconst flex_int16_t yy_base[39] =
 419     {   0,
 420         0,    0,   48,   49,   17,   19,   35,   41,   39,   16,
 421         0,   14,   32,   15,   25,   27,   49,   49,   49,   27,
 422         0,    0,    0,   49,   49,   49,   49,   49,   49,   32,
 423         0,    0,    0,   49,   39,   29,   34,   36
 424     } ;
 425
 426 static yyconst flex_int16_t yy_def[39] =
 427     {   0,
 428        34,    1,   34,   34,   34,   34,   34,   34,   34,   34,
 429        35,   34,   34,   34,   34,   34,   34,   34,   34,   34,
 430        36,   37,   35,   34,   34,   34,   34,   34,   34,   36,
 431        37,   38,   38,    0,   34,   34,   34,   34
 432     } ;
 433
 434 static yyconst flex_int16_t yy_nxt[68] =
 435     {   0,
 436         4,    5,    6,    7,    8,    9,   10,   11,   11,    4,
 437        12,   13,   14,    4,    4,    4,    4,   15,   16,   16,
 438        16,   16,   20,   20,   24,   25,   27,   28,   16,   16,
 439        30,   21,   22,   20,   20,   31,   31,   33,   33,   33,
 440        23,   32,   29,   26,   19,   18,   17,   34,    3,   34,
 441        34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
 442        34,   34,   34,   34,   34,   34,   34
 443     } ;
 444
 445 static yyconst flex_int16_t yy_chk[68] =
 446     {   0,
 447         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 448         1,    1,    1,    1,    1,    1,    1,    1,    5,    5,
 449         6,    6,   10,   10,   12,   12,   14,   14,   16,   16,
 450        36,   10,   10,   20,   20,   37,   37,   38,   38,   38,
 451        35,   30,   15,   13,    9,    8,    7,    3,   34,   34,
 452        34,   34,   34,   34,   34,   34,   34,   34,   34,   34,
 453        34,   34,   34,   34,   34,   34,   34
 454     } ;
 455
 456 static yy_state_type yy_last_accepting_state;
 457 static char *yy_last_accepting_cpos;
 458
 459 extern int yy_flex_debug;
 460 int yy_flex_debug = 0;
 461
 462 /* The intent behind this definition is that it'll catch
 463  * any uses of REJECT which flex missed.
 464  */
 465 #define REJECT reject_used_but_not_detected
 466 #define yymore() yymore_used_but_not_detected
 467 #define YY_MORE_ADJ 0
 468 #define YY_RESTORE_YY_MORE_OFFSET
 469 char *yytext;
 470 #line 1 "/usr/src/usr.bin/m4/tokenizer.l"
 471 #define YY_NO_INPUT 1
 472 #line 3 "/usr/src/usr.bin/m4/tokenizer.l"
 473 /* $OpenBSD: tokenizer.l,v 1.7 2010/03/22 20:40:44 espie Exp $ */
 474 /*
 475  * Copyright (c) 2004 Marc Espie <espie@cvs.openbsd.org>
 476  *
 477  * Permission to use, copy, modify, and distribute this software for any
 478  * purpose with or without fee is hereby granted, provided that the above
 479  * copyright notice and this permission notice appear in all copies.
 480  *
 481  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 482  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 483  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 484  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 485  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 486  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 487  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 488  *
 489  * $FreeBSD: src/usr.bin/m4/tokenizer.l,v 1.3 2012/11/17 01:54:24 svnexp Exp $
 490  */
 491
 492 #include "parser.h"
 493 #include <assert.h>
 494 #include <stdlib.h>
 495 #include <errno.h>
 496 #include <stdint.h>
 497 #include <limits.h>
 498 #include <sys/param.h>
 499
 500 extern int mimic_gnu;
 501 extern int32_t yylval;
 502
 503 int32_t number(void);
 504 int32_t parse_radix(void);
 505 #line 506 "<stdout>"
 506
 507 #define INITIAL 0
 508
 509 #ifndef YY_NO_UNISTD_H
 510 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 511  * down here because we want the user's section 1 to have been scanned first.
 512  * The user has a chance to override it with an option.
 513  */
 514 #include <unistd.h>
 515 #endif
 516
 517 #ifndef YY_EXTRA_TYPE
 518 #define YY_EXTRA_TYPE void *
 519 #endif
 520
 521 static int yy_init_globals (void );
 522
 523 /* Accessor methods to globals.
 524    These are made visible to non-reentrant scanners for convenience. */
 525
 526 int yylex_destroy (void );
 527
 528 int yyget_debug (void );
 529
 530 void yyset_debug (int debug_flag  );
 531
 532 YY_EXTRA_TYPE yyget_extra (void );
 533
 534 void yyset_extra (YY_EXTRA_TYPE user_defined  );
 535
 536 FILE *yyget_in (void );
 537
 538 void yyset_in  (FILE * in_str  );
 539
 540 FILE *yyget_out (void );
 541
 542 void yyset_out  (FILE * out_str  );
 543
 544 yy_size_t yyget_leng (void );
 545
 546 char *yyget_text (void );
 547
 548 int yyget_lineno (void );
 549
 550 void yyset_lineno (int line_number  );
 551
 552 /* Macros after this point can all be overridden by user definitions in
 553  * section 1.
 554  */
 555
 556 #ifndef YY_SKIP_YYWRAP
 557 #ifdef __cplusplus
 558 extern "C" int yywrap (void );
 559 #else
 560 extern int yywrap (void );
 561 #endif
 562 #endif
 563
 564 #ifndef yytext_ptr
 565 static void yy_flex_strncpy (char *,yyconst char *,int );
 566 #endif
 567
 568 #ifdef YY_NEED_STRLEN
 569 static int yy_flex_strlen (yyconst char * );
 570 #endif
 571
 572 #ifndef YY_NO_INPUT
 573
 574 #ifdef __cplusplus
 575 static int yyinput (void );
 576 #else
 577 static int input (void );
 578 #endif
 579
 580 #endif
 581
 582 /* Amount of stuff to slurp up with each read. */
 583 #ifndef YY_READ_BUF_SIZE
 584 #define YY_READ_BUF_SIZE 8192
 585 #endif
 586
 587 /* Copy whatever the last rule matched to the standard output. */
 588 #ifndef ECHO
 589 /* This used to be an fputs(), but since the string might contain NUL's,
 590  * we now use fwrite().
 591  */
 592 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
 593 #endif
 594
 595 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 596  * is returned in "result".
 597  */
 598 #ifndef YY_INPUT
 599 #define YY_INPUT(buf,result,max_size) \
 600         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 601                 { \
 602                 int c = '*'; \
 603                 size_t n; \
 604                 for ( n = 0; n < max_size && \
 605                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 606                         buf[n] = (char) c; \
 607                 if ( c == '\n' ) \
 608                         buf[n++] = (char) c; \
 609                 if ( c == EOF && ferror( yyin ) ) \
 610                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 611                 result = n; \
 612                 } \
 613         else \
 614                 { \
 615                 errno=0; \
 616                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 617                         { \
 618                         if( errno != EINTR) \
 619                                 { \
 620                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 621                                 break; \
 622                                 } \
 623                         errno=0; \
 624                         clearerr(yyin); \
 625                         } \
 626                 }\
 627 \
 628
 629 #endif
 630
 631 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 632  * we don't want an extra ';' after the "return" because that will cause
 633  * some compilers to complain about unreachable statements.
 634  */
 635 #ifndef yyterminate
 636 #define yyterminate() return YY_NULL
 637 #endif
 638
 639 /* Number of entries by which start-condition stack grows. */
 640 #ifndef YY_START_STACK_INCR
 641 #define YY_START_STACK_INCR 25
 642 #endif
 643
 644 /* Report a fatal error. */
 645 #ifndef YY_FATAL_ERROR
 646 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 647 #endif
 648
 649 /* end tables serialization structures and prototypes */
 650
 651 /* Default declaration of generated scanner - a define so the user can
 652  * easily add parameters.
 653  */
 654 #ifndef YY_DECL
 655 #define YY_DECL_IS_OURS 1
 656
 657 extern int yylex (void);
 658
 659 #define YY_DECL int yylex (void)
 660 #endif /* !YY_DECL */
 661
 662 /* Code executed at the beginning of each rule, after yytext and yyleng
 663  * have been set up.
 664  */
 665 #ifndef YY_USER_ACTION
 666 #define YY_USER_ACTION
 667 #endif
 668
 669 /* Code executed at the end of each rule. */
 670 #ifndef YY_BREAK
 671 #define YY_BREAK break;
 672 #endif
 673
 674 #define YY_RULE_SETUP \
 675         YY_USER_ACTION
 676
 677 /** The main scanner function which does all the work.
 678  */
 679 YY_DECL
 680 {
 681         register yy_state_type yy_current_state;
 682         register char *yy_cp, *yy_bp;
 683         register int yy_act;
 684
 685 #line 44 "/usr/src/usr.bin/m4/tokenizer.l"
 686
 687 #line 688 "<stdout>"
 688
 689         if ( !(yy_init) )
 690                 {
 691                 (yy_init) = 1;
 692
 693 #ifdef YY_USER_INIT
 694                 YY_USER_INIT;
 695 #endif
 696
 697                 if ( ! (yy_start) )
 698                         (yy_start) = 1; /* first start state */
 699
 700                 if ( ! yyin )
 701                         yyin = stdin;
 702
 703                 if ( ! yyout )
 704                         yyout = stdout;
 705
 706                 if ( ! YY_CURRENT_BUFFER ) {
 707                         yyensure_buffer_stack ();
 708                         YY_CURRENT_BUFFER_LVALUE =
 709                                 yy_create_buffer(yyin,YY_BUF_SIZE );
 710                 }
 711
 712                 yy_load_buffer_state( );
 713                 }
 714
 715         while ( 1 )             /* loops until end-of-file is reached */
 716                 {
 717                 yy_cp = (yy_c_buf_p);
 718
 719                 /* Support of yytext. */
 720                 *yy_cp = (yy_hold_char);
 721
 722                 /* yy_bp points to the position in yy_ch_buf of the start of
 723                  * the current run.
 724                  */
 725                 yy_bp = yy_cp;
 726
 727                 yy_current_state = (yy_start);
 728 yy_match:
 729                 do
 730                         {
 731                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 732                         if ( yy_accept[yy_current_state] )
 733                                 {
 734                                 (yy_last_accepting_state) = yy_current_state;
 735                                 (yy_last_accepting_cpos) = yy_cp;
 736                                 }
 737                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 738                                 {
 739                                 yy_current_state = (int) yy_def[yy_current_state];
 740                                 if ( yy_current_state >= 35 )
 741                                         yy_c = yy_meta[(unsigned int) yy_c];
 742                                 }
 743                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 744                         ++yy_cp;
 745                         }
 746                 while ( yy_base[yy_current_state] != 49 );
 747
 748 yy_find_action:
 749                 yy_act = yy_accept[yy_current_state];
 750                 if ( yy_act == 0 )
 751                         { /* have to back up */
 752                         yy_cp = (yy_last_accepting_cpos);
 753                         yy_current_state = (yy_last_accepting_state);
 754                         yy_act = yy_accept[yy_current_state];
 755                         }
 756
 757                 YY_DO_BEFORE_ACTION;
 758
 759 do_action:      /* This label is used only to access EOF actions. */
 760
 761                 switch ( yy_act )
 762         { /* beginning of action switch */
 763                         case 0: /* must back up */
 764                         /* undo the effects of YY_DO_BEFORE_ACTION */
 765                         *yy_cp = (yy_hold_char);
 766                         yy_cp = (yy_last_accepting_cpos);
 767                         yy_current_state = (yy_last_accepting_state);
 768                         goto yy_find_action;
 769
 770 case 1:
 771 /* rule 1 can match eol */
 772 YY_RULE_SETUP
 773 #line 45 "/usr/src/usr.bin/m4/tokenizer.l"
 774 {/* just skip it */}
 775         YY_BREAK
 776 case 2:
 777 YY_RULE_SETUP
 778 #line 46 "/usr/src/usr.bin/m4/tokenizer.l"
 779 { yylval = number(); return(NUMBER); }
 780         YY_BREAK
 781 case 3:
 782 YY_RULE_SETUP
 783 #line 47 "/usr/src/usr.bin/m4/tokenizer.l"
 784 { if (mimic_gnu) {
 785                                 yylval = parse_radix(); return(NUMBER);
 786                           } else {
 787                                 return(ERROR);
 788                           }
 789                         }
 790         YY_BREAK
 791 case 4:
 792 YY_RULE_SETUP
 793 #line 53 "/usr/src/usr.bin/m4/tokenizer.l"
 794 { return(LE); }
 795         YY_BREAK
 796 case 5:
 797 YY_RULE_SETUP
 798 #line 54 "/usr/src/usr.bin/m4/tokenizer.l"
 799 { return(GE); }
 800         YY_BREAK
 801 case 6:
 802 YY_RULE_SETUP
 803 #line 55 "/usr/src/usr.bin/m4/tokenizer.l"
 804 { return(LSHIFT); }
 805         YY_BREAK
 806 case 7:
 807 YY_RULE_SETUP
 808 #line 56 "/usr/src/usr.bin/m4/tokenizer.l"
 809 { return(RSHIFT); }
 810         YY_BREAK
 811 case 8:
 812 YY_RULE_SETUP
 813 #line 57 "/usr/src/usr.bin/m4/tokenizer.l"
 814 { return(EQ); }
 815         YY_BREAK
 816 case 9:
 817 YY_RULE_SETUP
 818 #line 58 "/usr/src/usr.bin/m4/tokenizer.l"
 819 { return(NE); }
 820         YY_BREAK
 821 case 10:
 822 YY_RULE_SETUP
 823 #line 59 "/usr/src/usr.bin/m4/tokenizer.l"
 824 { return(LAND); }
 825         YY_BREAK
 826 case 11:
 827 YY_RULE_SETUP
 828 #line 60 "/usr/src/usr.bin/m4/tokenizer.l"
 829 { return(LOR); }
 830         YY_BREAK
 831 case 12:
 832 YY_RULE_SETUP
 833 #line 61 "/usr/src/usr.bin/m4/tokenizer.l"
 834 { if (mimic_gnu) { return (EXPONENT); } }
 835         YY_BREAK
 836 case 13:
 837 YY_RULE_SETUP
 838 #line 62 "/usr/src/usr.bin/m4/tokenizer.l"
 839 { return yytext[0]; }
 840         YY_BREAK
 841 case 14:
 842 YY_RULE_SETUP
 843 #line 63 "/usr/src/usr.bin/m4/tokenizer.l"
 844 ECHO;
 845         YY_BREAK
 846 #line 847 "<stdout>"
 847 case YY_STATE_EOF(INITIAL):
 848         yyterminate();
 849
 850         case YY_END_OF_BUFFER:
 851                 {
 852                 /* Amount of text matched not including the EOB char. */
 853                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 854
 855                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 856                 *yy_cp = (yy_hold_char);
 857                 YY_RESTORE_YY_MORE_OFFSET
 858
 859                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
 860                         {
 861                         /* We're scanning a new file or input source.  It's
 862                          * possible that this happened because the user
 863                          * just pointed yyin at a new source and called
 864                          * yylex().  If so, then we have to assure
 865                          * consistency between YY_CURRENT_BUFFER and our
 866                          * globals.  Here is the right place to do so, because
 867                          * this is the first action (other than possibly a
 868                          * back-up) that will match for the new input source.
 869                          */
 870                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 871                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
 872                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 873                         }
 874
 875                 /* Note that here we test for yy_c_buf_p "<=" to the position
 876                  * of the first EOB in the buffer, since yy_c_buf_p will
 877                  * already have been incremented past the NUL character
 878                  * (since all states make transitions on EOB to the
 879                  * end-of-buffer state).  Contrast this with the test
 880                  * in input().
 881                  */
 882                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
 883                         { /* This was really a NUL. */
 884                         yy_state_type yy_next_state;
 885
 886                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 887
 888                         yy_current_state = yy_get_previous_state(  );
 889
 890                         /* Okay, we're now positioned to make the NUL
 891                          * transition.  We couldn't have
 892                          * yy_get_previous_state() go ahead and do it
 893                          * for us because it doesn't know how to deal
 894                          * with the possibility of jamming (and we don't
 895                          * want to build jamming into it because then it
 896                          * will run more slowly).
 897                          */
 898
 899                         yy_next_state = yy_try_NUL_trans( yy_current_state );
 900
 901                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 902
 903                         if ( yy_next_state )
 904                                 {
 905                                 /* Consume the NUL. */
 906                                 yy_cp = ++(yy_c_buf_p);
 907                                 yy_current_state = yy_next_state;
 908                                 goto yy_match;
 909                                 }
 910
 911                         else
 912                                 {
 913                                 yy_cp = (yy_c_buf_p);
 914                                 goto yy_find_action;
 915                                 }
 916                         }
 917
 918                 else switch ( yy_get_next_buffer(  ) )
 919                         {
 920                         case EOB_ACT_END_OF_FILE:
 921                                 {
 922                                 (yy_did_buffer_switch_on_eof) = 0;
 923
 924                                 if ( yywrap( ) )
 925                                         {
 926                                         /* Note: because we've taken care in
 927                                          * yy_get_next_buffer() to have set up
 928                                          * yytext, we can now set up
 929                                          * yy_c_buf_p so that if some total
 930                                          * hoser (like flex itself) wants to
 931                                          * call the scanner after we return the
 932                                          * YY_NULL, it'll still work - another
 933                                          * YY_NULL will get returned.
 934                                          */
 935                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
 936
 937                                         yy_act = YY_STATE_EOF(YY_START);
 938                                         goto do_action;
 939                                         }
 940
 941                                 else
 942                                         {
 943                                         if ( ! (yy_did_buffer_switch_on_eof) )
 944                                                 YY_NEW_FILE;
 945                                         }
 946                                 break;
 947                                 }
 948
 949                         case EOB_ACT_CONTINUE_SCAN:
 950                                 (yy_c_buf_p) =
 951                                         (yytext_ptr) + yy_amount_of_matched_text;
 952
 953                                 yy_current_state = yy_get_previous_state(  );
 954
 955                                 yy_cp = (yy_c_buf_p);
 956                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 957                                 goto yy_match;
 958
 959                         case EOB_ACT_LAST_MATCH:
 960                                 (yy_c_buf_p) =
 961                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
 962
 963                                 yy_current_state = yy_get_previous_state(  );
 964
 965                                 yy_cp = (yy_c_buf_p);
 966                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 967                                 goto yy_find_action;
 968                         }
 969                 break;
 970                 }
 971
 972         default:
 973                 YY_FATAL_ERROR(
 974                         "fatal flex scanner internal error--no action found" );
 975         } /* end of action switch */
 976                 } /* end of scanning one token */
 977 } /* end of yylex */
 978
 979 /* yy_get_next_buffer - try to read in a new buffer
 980  *
 981  * Returns a code representing an action:
 982  *      EOB_ACT_LAST_MATCH -
 983  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 984  *      EOB_ACT_END_OF_FILE - end of file
 985  */
 986 static int yy_get_next_buffer (void)
 987 {
 988         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
 989         register char *source = (yytext_ptr);
 990         register int number_to_move, i;
 991         int ret_val;
 992
 993         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
 994                 YY_FATAL_ERROR(
 995                 "fatal flex scanner internal error--end of buffer missed" );
 996
 997         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
 998                 { /* Don't try to fill the buffer, so this is an EOF. */
 999                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1000                         {
1001                         /* We matched a single character, the EOB, so
1002                          * treat this as a final EOF.
1003                          */
1004                         return EOB_ACT_END_OF_FILE;
1005                         }
1006
1007                 else
1008                         {
1009                         /* We matched some text prior to the EOB, first
1010                          * process it.
1011                          */
1012                         return EOB_ACT_LAST_MATCH;
1013                         }
1014                 }
1015
1016         /* Try to read more data. */
1017
1018         /* First move last chars to start of buffer. */
1019         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1020
1021         for ( i = 0; i < number_to_move; ++i )
1022                 *(dest++) = *(source++);
1023
1024         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1025                 /* don't do the read, it's not guaranteed to return an EOF,
1026                  * just force an EOF
1027                  */
1028                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1029
1030         else
1031                 {
1032                         yy_size_t num_to_read =
1033                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1034
1035                 while ( num_to_read <= 0 )
1036                         { /* Not enough room in the buffer - grow it. */
1037
1038                         /* just a shorter name for the current buffer */
1039                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1040
1041                         int yy_c_buf_p_offset =
1042                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1043
1044                         if ( b->yy_is_our_buffer )
1045                                 {
1046                                 yy_size_t new_size = b->yy_buf_size * 2;
1047
1048                                 if ( new_size <= 0 )
1049                                         b->yy_buf_size += b->yy_buf_size / 8;
1050                                 else
1051                                         b->yy_buf_size *= 2;
1052
1053                                 b->yy_ch_buf = (char *)
1054                                         /* Include room in for 2 EOB chars. */
1055                                         yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1056                                 }
1057                         else
1058                                 /* Can't grow it, we don't own it. */
1059                                 b->yy_ch_buf = 0;
1060
1061                         if ( ! b->yy_ch_buf )
1062                                 YY_FATAL_ERROR(
1063                                 "fatal error - scanner input buffer overflow" );
1064
1065                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1066
1067                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1068                                                 number_to_move - 1;
1069
1070                         }
1071
1072                 if ( num_to_read > YY_READ_BUF_SIZE )
1073                         num_to_read = YY_READ_BUF_SIZE;
1074
1075                 /* Read in more data. */
1076                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1077                         (yy_n_chars), num_to_read );
1078
1079                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1080                 }
1081
1082         if ( (yy_n_chars) == 0 )
1083                 {
1084                 if ( number_to_move == YY_MORE_ADJ )
1085                         {
1086                         ret_val = EOB_ACT_END_OF_FILE;
1087                         yyrestart(yyin  );
1088                         }
1089
1090                 else
1091                         {
1092                         ret_val = EOB_ACT_LAST_MATCH;
1093                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1094                                 YY_BUFFER_EOF_PENDING;
1095                         }
1096                 }
1097
1098         else
1099                 ret_val = EOB_ACT_CONTINUE_SCAN;
1100
1101         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1102                 /* Extend the array by 50%, plus the number we really need. */
1103                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1104                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
1105                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1106                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1107         }
1108
1109         (yy_n_chars) += number_to_move;
1110         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1111         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1112
1113         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1114
1115         return ret_val;
1116 }
1117
1118 /* yy_get_previous_state - get the state just before the EOB char was reached */
1119
1120     static yy_state_type yy_get_previous_state (void)
1121 {
1122         register yy_state_type yy_current_state;
1123         register char *yy_cp;
1124
1125         yy_current_state = (yy_start);
1126
1127         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1128                 {
1129                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1130                 if ( yy_accept[yy_current_state] )
1131                         {
1132                         (yy_last_accepting_state) = yy_current_state;
1133                         (yy_last_accepting_cpos) = yy_cp;
1134                         }
1135                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1136                         {
1137                         yy_current_state = (int) yy_def[yy_current_state];
1138                         if ( yy_current_state >= 35 )
1139                                 yy_c = yy_meta[(unsigned int) yy_c];
1140                         }
1141                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1142                 }
1143
1144         return yy_current_state;
1145 }
1146
1147 /* yy_try_NUL_trans - try to make a transition on the NUL character
1148  *
1149  * synopsis
1150  *      next_state = yy_try_NUL_trans( current_state );
1151  */
1152     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1153 {
1154         register int yy_is_jam;
1155         register char *yy_cp = (yy_c_buf_p);
1156
1157         register YY_CHAR yy_c = 1;
1158         if ( yy_accept[yy_current_state] )
1159                 {
1160                 (yy_last_accepting_state) = yy_current_state;
1161                 (yy_last_accepting_cpos) = yy_cp;
1162                 }
1163         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1164                 {
1165                 yy_current_state = (int) yy_def[yy_current_state];
1166                 if ( yy_current_state >= 35 )
1167                         yy_c = yy_meta[(unsigned int) yy_c];
1168                 }
1169         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1170         yy_is_jam = (yy_current_state == 34);
1171
1172                 return yy_is_jam ? 0 : yy_current_state;
1173 }
1174
1175 #ifndef YY_NO_INPUT
1176 #ifdef __cplusplus
1177     static int yyinput (void)
1178 #else
1179     static int input  (void)
1180 #endif
1181
1182 {
1183         int c;
1184
1185         *(yy_c_buf_p) = (yy_hold_char);
1186
1187         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1188                 {
1189                 /* yy_c_buf_p now points to the character we want to return.
1190                  * If this occurs *before* the EOB characters, then it's a
1191                  * valid NUL; if not, then we've hit the end of the buffer.
1192                  */
1193                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1194                         /* This was really a NUL. */
1195                         *(yy_c_buf_p) = '\0';
1196
1197                 else
1198                         { /* need more input */
1199                         yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
1200                         ++(yy_c_buf_p);
1201
1202                         switch ( yy_get_next_buffer(  ) )
1203                                 {
1204                                 case EOB_ACT_LAST_MATCH:
1205                                         /* This happens because yy_g_n_b()
1206                                          * sees that we've accumulated a
1207                                          * token and flags that we need to
1208                                          * try matching the token before
1209                                          * proceeding.  But for input(),
1210                                          * there's no matching to consider.
1211                                          * So convert the EOB_ACT_LAST_MATCH
1212                                          * to EOB_ACT_END_OF_FILE.
1213                                          */
1214
1215                                         /* Reset buffer status. */
1216                                         yyrestart(yyin );
1217
1218                                         /*FALLTHROUGH*/
1219
1220                                 case EOB_ACT_END_OF_FILE:
1221                                         {
1222                                         if ( yywrap( ) )
1223                                                 return EOF;
1224
1225                                         if ( ! (yy_did_buffer_switch_on_eof) )
1226                                                 YY_NEW_FILE;
1227 #ifdef __cplusplus
1228                                         return yyinput();
1229 #else
1230                                         return input();
1231 #endif
1232                                         }
1233
1234                                 case EOB_ACT_CONTINUE_SCAN:
1235                                         (yy_c_buf_p) = (yytext_ptr) + offset;
1236                                         break;
1237                                 }
1238                         }
1239                 }
1240
1241         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1242         *(yy_c_buf_p) = '\0';   /* preserve yytext */
1243         (yy_hold_char) = *++(yy_c_buf_p);
1244
1245         return c;
1246 }
1247 #endif  /* ifndef YY_NO_INPUT */
1248
1249 /** Immediately switch to a different input stream.
1250  * @param input_file A readable stream.
1251  *
1252  * @note This function does not reset the start condition to @c INITIAL .
1253  */
1254     void yyrestart  (FILE * input_file )
1255 {
1256
1257         if ( ! YY_CURRENT_BUFFER ){
1258         yyensure_buffer_stack ();
1259                 YY_CURRENT_BUFFER_LVALUE =
1260             yy_create_buffer(yyin,YY_BUF_SIZE );
1261         }
1262
1263         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1264         yy_load_buffer_state( );
1265 }
1266
1267 /** Switch to a different input buffer.
1268  * @param new_buffer The new input buffer.
1269  *
1270  */
1271     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1272 {
1273
1274         /* TODO. We should be able to replace this entire function body
1275          * with
1276          *              yypop_buffer_state();
1277          *              yypush_buffer_state(new_buffer);
1278      */
1279         yyensure_buffer_stack ();
1280         if ( YY_CURRENT_BUFFER == new_buffer )
1281                 return;
1282
1283         if ( YY_CURRENT_BUFFER )
1284                 {
1285                 /* Flush out information for old buffer. */
1286                 *(yy_c_buf_p) = (yy_hold_char);
1287                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1288                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1289                 }
1290
1291         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1292         yy_load_buffer_state( );
1293
1294         /* We don't actually know whether we did this switch during
1295          * EOF (yywrap()) processing, but the only time this flag
1296          * is looked at is after yywrap() is called, so it's safe
1297          * to go ahead and always set it.
1298          */
1299         (yy_did_buffer_switch_on_eof) = 1;
1300 }
1301
1302 static void yy_load_buffer_state  (void)
1303 {
1304         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1305         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1306         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1307         (yy_hold_char) = *(yy_c_buf_p);
1308 }
1309
1310 /** Allocate and initialize an input buffer state.
1311  * @param file A readable stream.
1312  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1313  *
1314  * @return the allocated buffer state.
1315  */
1316     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
1317 {
1318         YY_BUFFER_STATE b;
1319
1320         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1321         if ( ! b )
1322                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1323
1324         b->yy_buf_size = size;
1325
1326         /* yy_ch_buf has to be 2 characters longer than the size given because
1327          * we need to put in 2 end-of-buffer characters.
1328          */
1329         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
1330         if ( ! b->yy_ch_buf )
1331                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1332
1333         b->yy_is_our_buffer = 1;
1334
1335         yy_init_buffer(b,file );
1336
1337         return b;
1338 }
1339
1340 /** Destroy the buffer.
1341  * @param b a buffer created with yy_create_buffer()
1342  *
1343  */
1344     void yy_delete_buffer (YY_BUFFER_STATE  b )
1345 {
1346
1347         if ( ! b )
1348                 return;
1349
1350         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1351                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1352
1353         if ( b->yy_is_our_buffer )
1354                 yyfree((void *) b->yy_ch_buf  );
1355
1356         yyfree((void *) b  );
1357 }
1358
1359 /* Initializes or reinitializes a buffer.
1360  * This function is sometimes called more than once on the same buffer,
1361  * such as during a yyrestart() or at EOF.
1362  */
1363     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1364
1365 {
1366         int oerrno = errno;
1367
1368         yy_flush_buffer(b );
1369
1370         b->yy_input_file = file;
1371         b->yy_fill_buffer = 1;
1372
1373     /* If b is the current buffer, then yy_init_buffer was _probably_
1374      * called from yyrestart() or through yy_get_next_buffer.
1375      * In that case, we don't want to reset the lineno or column.
1376      */
1377     if (b != YY_CURRENT_BUFFER){
1378         b->yy_bs_lineno = 1;
1379         b->yy_bs_column = 0;
1380     }
1381
1382         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1383
1384         errno = oerrno;
1385 }
1386
1387 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1388  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1389  *
1390  */
1391     void yy_flush_buffer (YY_BUFFER_STATE  b )
1392 {
1393         if ( ! b )
1394                 return;
1395
1396         b->yy_n_chars = 0;
1397
1398         /* We always need two end-of-buffer characters.  The first causes
1399          * a transition to the end-of-buffer state.  The second causes
1400          * a jam in that state.
1401          */
1402         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1403         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1404
1405         b->yy_buf_pos = &b->yy_ch_buf[0];
1406
1407         b->yy_at_bol = 1;
1408         b->yy_buffer_status = YY_BUFFER_NEW;
1409
1410         if ( b == YY_CURRENT_BUFFER )
1411                 yy_load_buffer_state( );
1412 }
1413
1414 /** Pushes the new state onto the stack. The new state becomes
1415  *  the current state. This function will allocate the stack
1416  *  if necessary.
1417  *  @param new_buffer The new state.
1418  *
1419  */
1420 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1421 {
1422         if (new_buffer == NULL)
1423                 return;
1424
1425         yyensure_buffer_stack();
1426
1427         /* This block is copied from yy_switch_to_buffer. */
1428         if ( YY_CURRENT_BUFFER )
1429                 {
1430                 /* Flush out information for old buffer. */
1431                 *(yy_c_buf_p) = (yy_hold_char);
1432                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1433                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1434                 }
1435
1436         /* Only push if top exists. Otherwise, replace top. */
1437         if (YY_CURRENT_BUFFER)
1438                 (yy_buffer_stack_top)++;
1439         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1440
1441         /* copied from yy_switch_to_buffer. */
1442         yy_load_buffer_state( );
1443         (yy_did_buffer_switch_on_eof) = 1;
1444 }
1445
1446 /** Removes and deletes the top of the stack, if present.
1447  *  The next element becomes the new top.
1448  *
1449  */
1450 void yypop_buffer_state (void)
1451 {
1452         if (!YY_CURRENT_BUFFER)
1453                 return;
1454
1455         yy_delete_buffer(YY_CURRENT_BUFFER );
1456         YY_CURRENT_BUFFER_LVALUE = NULL;
1457         if ((yy_buffer_stack_top) > 0)
1458                 --(yy_buffer_stack_top);
1459
1460         if (YY_CURRENT_BUFFER) {
1461                 yy_load_buffer_state( );
1462                 (yy_did_buffer_switch_on_eof) = 1;
1463         }
1464 }
1465
1466 /* Allocates the stack if it does not exist.
1467  *  Guarantees space for at least one push.
1468  */
1469 static void yyensure_buffer_stack (void)
1470 {
1471         yy_size_t num_to_alloc;
1472
1473         if (!(yy_buffer_stack)) {
1474
1475                 /* First allocation is just for 2 elements, since we don't know if this
1476                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1477                  * immediate realloc on the next call.
1478          */
1479                 num_to_alloc = 1;
1480                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1481                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1482                                                                 );
1483                 if ( ! (yy_buffer_stack) )
1484                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1485
1486                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1487
1488                 (yy_buffer_stack_max) = num_to_alloc;
1489                 (yy_buffer_stack_top) = 0;
1490                 return;
1491         }
1492
1493         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1494
1495                 /* Increase the buffer to prepare for a possible push. */
1496                 int grow_size = 8 /* arbitrary grow size */;
1497
1498                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1499                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1500                                                                 ((yy_buffer_stack),
1501                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1502                                                                 );
1503                 if ( ! (yy_buffer_stack) )
1504                         YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1505
1506                 /* zero only the new slots.*/
1507                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1508                 (yy_buffer_stack_max) = num_to_alloc;
1509         }
1510 }
1511
1512 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1513  * @param base the character buffer
1514  * @param size the size in bytes of the character buffer
1515  *
1516  * @return the newly allocated buffer state object.
1517  */
1518 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
1519 {
1520         YY_BUFFER_STATE b;
1521
1522         if ( size < 2 ||
1523              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1524              base[size-1] != YY_END_OF_BUFFER_CHAR )
1525                 /* They forgot to leave room for the EOB's. */
1526                 return 0;
1527
1528         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1529         if ( ! b )
1530                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1531
1532         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1533         b->yy_buf_pos = b->yy_ch_buf = base;
1534         b->yy_is_our_buffer = 0;
1535         b->yy_input_file = 0;
1536         b->yy_n_chars = b->yy_buf_size;
1537         b->yy_is_interactive = 0;
1538         b->yy_at_bol = 1;
1539         b->yy_fill_buffer = 0;
1540         b->yy_buffer_status = YY_BUFFER_NEW;
1541
1542         yy_switch_to_buffer(b  );
1543
1544         return b;
1545 }
1546
1547 /** Setup the input buffer state to scan a string. The next call to yylex() will
1548  * scan from a @e copy of @a str.
1549  * @param yystr a NUL-terminated string to scan
1550  *
1551  * @return the newly allocated buffer state object.
1552  * @note If you want to scan bytes that may contain NUL values, then use
1553  *       yy_scan_bytes() instead.
1554  */
1555 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
1556 {
1557
1558         return yy_scan_bytes(yystr,strlen(yystr) );
1559 }
1560
1561 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1562  * scan from a @e copy of @a bytes.
1563  * @param yybytes the byte buffer to scan
1564  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1565  *
1566  * @return the newly allocated buffer state object.
1567  */
1568 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
1569 {
1570         YY_BUFFER_STATE b;
1571         char *buf;
1572         yy_size_t n;
1573         yy_size_t i;
1574
1575         /* Get memory for full buffer, including space for trailing EOB's. */
1576         n = _yybytes_len + 2;
1577         buf = (char *) yyalloc(n  );
1578         if ( ! buf )
1579                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1580
1581         for ( i = 0; i < _yybytes_len; ++i )
1582                 buf[i] = yybytes[i];
1583
1584         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1585
1586         b = yy_scan_buffer(buf,n );
1587         if ( ! b )
1588                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1589
1590         /* It's okay to grow etc. this buffer, and we should throw it
1591          * away when we're done.
1592          */
1593         b->yy_is_our_buffer = 1;
1594
1595         return b;
1596 }
1597
1598 #ifndef YY_EXIT_FAILURE
1599 #define YY_EXIT_FAILURE 2
1600 #endif
1601
1602 static void yy_fatal_error (yyconst char* msg )
1603 {
1604         (void) fprintf( stderr, "%s\n", msg );
1605         exit( YY_EXIT_FAILURE );
1606 }
1607
1608 /* Redefine yyless() so it works in section 3 code. */
1609
1610 #undef yyless
1611 #define yyless(n) \
1612         do \
1613                 { \
1614                 /* Undo effects of setting up yytext. */ \
1615         int yyless_macro_arg = (n); \
1616         YY_LESS_LINENO(yyless_macro_arg);\
1617                 yytext[yyleng] = (yy_hold_char); \
1618                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1619                 (yy_hold_char) = *(yy_c_buf_p); \
1620                 *(yy_c_buf_p) = '\0'; \
1621                 yyleng = yyless_macro_arg; \
1622                 } \
1623         while ( 0 )
1624
1625 /* Accessor  methods (get/set functions) to struct members. */
1626
1627 /** Get the current line number.
1628  *
1629  */
1630 int yyget_lineno  (void)
1631 {
1632
1633     return yylineno;
1634 }
1635
1636 /** Get the input stream.
1637  *
1638  */
1639 FILE *yyget_in  (void)
1640 {
1641         return yyin;
1642 }
1643
1644 /** Get the output stream.
1645  *
1646  */
1647 FILE *yyget_out  (void)
1648 {
1649         return yyout;
1650 }
1651
1652 /** Get the length of the current token.
1653  *
1654  */
1655 yy_size_t yyget_leng  (void)
1656 {
1657         return yyleng;
1658 }
1659
1660 /** Get the current token.
1661  *
1662  */
1663
1664 char *yyget_text  (void)
1665 {
1666         return yytext;
1667 }
1668
1669 /** Set the current line number.
1670  * @param line_number
1671  *
1672  */
1673 void yyset_lineno (int  line_number )
1674 {
1675
1676     yylineno = line_number;
1677 }
1678
1679 /** Set the input stream. This does not discard the current
1680  * input buffer.
1681  * @param in_str A readable stream.
1682  *
1683  * @see yy_switch_to_buffer
1684  */
1685 void yyset_in (FILE *  in_str )
1686 {
1687         yyin = in_str ;
1688 }
1689
1690 void yyset_out (FILE *  out_str )
1691 {
1692         yyout = out_str ;
1693 }
1694
1695 int yyget_debug  (void)
1696 {
1697         return yy_flex_debug;
1698 }
1699
1700 void yyset_debug (int  bdebug )
1701 {
1702         yy_flex_debug = bdebug ;
1703 }
1704
1705 static int yy_init_globals (void)
1706 {
1707         /* Initialization is the same as for the non-reentrant scanner.
1708      * This function is called from yylex_destroy(), so don't allocate here.
1709      */
1710
1711     (yy_buffer_stack) = 0;
1712     (yy_buffer_stack_top) = 0;
1713     (yy_buffer_stack_max) = 0;
1714     (yy_c_buf_p) = (char *) 0;
1715     (yy_init) = 0;
1716     (yy_start) = 0;
1717
1718 /* Defined in main.c */
1719 #ifdef YY_STDINIT
1720     yyin = stdin;
1721     yyout = stdout;
1722 #else
1723     yyin = (FILE *) 0;
1724     yyout = (FILE *) 0;
1725 #endif
1726
1727     /* For future reference: Set errno on error, since we are called by
1728      * yylex_init()
1729      */
1730     return 0;
1731 }
1732
1733 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
1734 int yylex_destroy  (void)
1735 {
1736
1737     /* Pop the buffer stack, destroying each element. */
1738         while(YY_CURRENT_BUFFER){
1739                 yy_delete_buffer(YY_CURRENT_BUFFER  );
1740                 YY_CURRENT_BUFFER_LVALUE = NULL;
1741                 yypop_buffer_state();
1742         }
1743
1744         /* Destroy the stack itself. */
1745         yyfree((yy_buffer_stack) );
1746         (yy_buffer_stack) = NULL;
1747
1748     /* Reset the globals. This is important in a non-reentrant scanner so the next time
1749      * yylex() is called, initialization will occur. */
1750     yy_init_globals( );
1751
1752     return 0;
1753 }
1754
1755 /*
1756  * Internal utility routines.
1757  */
1758
1759 #ifndef yytext_ptr
1760 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1761 {
1762         register int i;
1763         for ( i = 0; i < n; ++i )
1764                 s1[i] = s2[i];
1765 }
1766 #endif
1767
1768 #ifdef YY_NEED_STRLEN
1769 static int yy_flex_strlen (yyconst char * s )
1770 {
1771         register int n;
1772         for ( n = 0; s[n]; ++n )
1773                 ;
1774
1775         return n;
1776 }
1777 #endif
1778
1779 void *yyalloc (yy_size_t  size )
1780 {
1781         return (void *) malloc( size );
1782 }
1783
1784 void *yyrealloc  (void * ptr, yy_size_t  size )
1785 {
1786         /* The cast to (char *) in the following accommodates both
1787          * implementations that use char* generic pointers, and those
1788          * that use void* generic pointers.  It works with the latter
1789          * because both ANSI C and C++ allow castless assignment from
1790          * any pointer type to void*, and deal with argument conversions
1791          * as though doing an assignment.
1792          */
1793         return (void *) realloc( (char *) ptr, size );
1794 }
1795
1796 void yyfree (void * ptr )
1797 {
1798         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
1799 }
1800
1801 #define YYTABLES_NAME "yytables"
1802
1803 #line 63 "/usr/src/usr.bin/m4/tokenizer.l"
1804
1805
1806
1807 int32_t
1808 number(void)
1809 {
1810         long l;
1811
1812         errno = 0;
1813         l = strtol(yytext, NULL, 0);
1814         if (((l == LONG_MAX || l == LONG_MIN) && errno == ERANGE) ||
1815             l > INT32_MAX || l < INT32_MIN) {
1816                 fprintf(stderr, "m4: numeric overflow in expr: %s\n", yytext);
1817         }
1818         return l;
1819 }
1820
1821 int32_t
1822 parse_radix(void)
1823 {
1824         long base;
1825         char *next;
1826         long l;
1827         int d;
1828
1829         l = 0;
1830         base = strtol(yytext + 2, &next, 0);
1831         if (base > 36 || next == NULL) {
1832                 fprintf(stderr, "m4: error in number %s\n", yytext);
1833         } else {
1834                 next++;
1835                 while (*next != 0) {
1836                         if (*next >= '0' && *next <= '9')
1837                                 d = *next - '0';
1838                         else if (*next >= 'a' && *next <= 'z')
1839                                 d = *next - 'a' + 10;
1840                         else {
1841                                 assert(*next >= 'A' && *next <= 'Z');
1842                                 d = *next - 'A' + 10;
1843                         }
1844                         if (d >= base) {
1845                                 fprintf(stderr,
1846                                     "m4: error in number %s\n", yytext);
1847                                 return 0;
1848                         }
1849                         l = base * l + d;
1850                         next++;
1851                 }
1852         }
1853         return l;
1854 }