cde/programs/dtinfo/DtMmdb/StyleSheet/defToken.C

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these libraries and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* A lexical scanner generated by flex */
  24
  25 /* scanner skeleton version:
  26  * $XConsortium: defToken.C /main/5 1996/08/21 15:57:31 drk $
  27  */
  28
  29 #define FLEX_SCANNER
  30
  31 #include <stdio.h>
  32
  33
  34 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  35 #ifdef c_plusplus
  36 #ifndef __cplusplus
  37 #define __cplusplus
  38 #endif
  39 #endif
  40
  41
  42 #ifdef __cplusplus
  43
  44 #include <stdlib.h>
  45
  46 #if !defined(__linux__) && !defined(CSRG_BASED) && !defined(sun)
  47 #include <osfcn.h>
  48 #endif
  49
  50 /* use prototypes in function declarations */
  51 #define defParser_USE_PROTOS
  52
  53 /* the "const" storage-class-modifier is valid */
  54 #define defParser_USE_CONST
  55
  56 #else   /* ! __cplusplus */
  57
  58 #ifdef __STDC__
  59
  60 #ifdef __GNUC__
  61 #include <stddef.h>
  62 void *malloc( size_t );
  63 void free( void* );
  64 #else
  65 #include <stdlib.h>
  66 #endif  /* __GNUC__ */
  67
  68 #define defParser_USE_PROTOS
  69 #define defParser_USE_CONST
  70
  71 #endif  /* __STDC__ */
  72 #endif  /* ! __cplusplus */
  73
  74
  75 #ifdef __TURBOC__
  76 #define defParser_USE_CONST
  77 #endif
  78
  79
  80 #ifndef defParser_USE_CONST
  81 #define const
  82 #endif
  83
  84
  85 #ifdef defParser_USE_PROTOS
  86 #define defParser_PROTO(proto) proto
  87 #else
  88 #define defParser_PROTO(proto) ()
  89 /* we can't get here if it's an ANSI C compiler, or a C++ compiler,
  90  * so it's got to be a K&R compiler, and therefore there's no standard
  91  * place from which to include these definitions
  92  */
  93 char *malloc();
  94 int free();
  95 int read();
  96 #endif
  97
  98
  99 /* amount of stuff to slurp up with each read */
 100 #ifndef defParser_READ_BUF_SIZE
 101 #define defParser_READ_BUF_SIZE 8192
 102 #endif
 103
 104 /* returned upon end-of-file */
 105 #define defParser_END_TOK 0
 106
 107 /* copy whatever the last rule matched to the standard output */
 108
 109 /* cast to (char *) is because for 8-bit chars, defParsertext is (unsigned char *) */
 110 /* this used to be an fputs(), but since the string might contain NUL's,
 111  * we now use fwrite()
 112  */
 113 #define ECHO (void) fwrite( (char *) defParsertext, defParserleng, 1, defParserout )
 114
 115 /* gets input and stuffs it into "buf".  number of characters read, or defParser_NULL,
 116  * is returned in "result".
 117  */
 118 #define defParser_INPUT(buf,result,max_size) \
 119         if ( (result = read( fileno(defParserin), (char *) buf, max_size )) < 0 ) \
 120             defParser_FATAL_ERROR( "read() in flex scanner failed" );
 121 #define defParser_NULL 0
 122
 123 /* no semi-colon after return; correct usage is to write "defParserterminate();" -
 124  * we don't want an extra ';' after the "return" because that will cause
 125  * some compilers to complain about unreachable statements.
 126  */
 127 #define defParserterminate() return ( defParser_NULL )
 128
 129 /* report a fatal error */
 130
 131 /* The funky do-while is used to turn this macro definition into
 132  * a single C statement (which needs a semi-colon terminator).
 133  * This avoids problems with code like:
 134  *
 135  *      if ( something_happens )
 136  *              defParser_FATAL_ERROR( "oops, the something happened" );
 137  *      else
 138  *              everything_okay();
 139  *
 140  * Prior to using the do-while the compiler would get upset at the
 141  * "else" because it interpreted the "if" statement as being all
 142  * done when it reached the ';' after the defParser_FATAL_ERROR() call.
 143  */
 144
 145 #define defParser_FATAL_ERROR(msg) \
 146         do \
 147                 { \
 148                 (void) fputs( msg, stderr ); \
 149                 (void) putc( '\n', stderr ); \
 150                 exit( 1 ); \
 151                 } \
 152         while ( 0 )
 153
 154 /* default defParserwrap function - always treat EOF as an EOF */
 155 #define defParserwrap() 1
 156
 157 /* enter a start condition.  This macro really ought to take a parameter,
 158  * but we do it the disgusting crufty way forced on us by the ()-less
 159  * definition of BEGIN
 160  */
 161 #define BEGIN defParser_start = 1 + 2 *
 162
 163 /* action number for EOF rule of a given start state */
 164 #define defParser_STATE_EOF(state) (defParser_END_OF_BUFFER + state + 1)
 165
 166 /* special action meaning "start processing a new file" */
 167 #define defParser_NEW_FILE \
 168         do \
 169                 { \
 170                 defParser_init_buffer( defParser_current_buffer, defParserin ); \
 171                 defParser_load_buffer_state(); \
 172                 } \
 173         while ( 0 )
 174
 175 /* default declaration of generated scanner - a define so the user can
 176  * easily add parameters
 177  */
 178 #define defParser_DECL int defParserlex defParser_PROTO(( void ))
 179
 180 /* code executed at the end of each rule */
 181 #define defParser_BREAK break;
 182
 183 #define defParser_END_OF_BUFFER_CHAR 0
 184
 185 #ifndef defParser_BUF_SIZE
 186 #define defParser_BUF_SIZE (defParser_READ_BUF_SIZE * 2) /* size of default input buffer */
 187 #endif
 188
 189 typedef struct defParser_buffer_state *defParser_BUFFER_STATE;
 190
 191 #define defParser_CHAR unsigned char
 192 # line 1 "defToken.l"
 193 #define INITIAL 0
 194 # line 10 "defToken.l"
 195 #include <string.h>
 196 #include "FeatureDefDictionary.h"
 197 #include "defParser.tab.h"
 198 #include "Debug.h"
 199 #include <iostream>
 200 using namespace std;
 201
 202 extern istream *g_defParserin;
 203
 204 #undef defParser_INPUT
 205 #define defParser_INPUT(buf,result,max_size)\
 206   {\
 207      if (g_defParserin -> eof()) {\
 208         result=0;\
 209      } else {\
 210         g_defParserin -> read((char *)buf, max_size-1); \
 211         result = g_defParserin -> gcount(); \
 212         buf[result] = 0; \
 213      }\
 214   }
 215
 216 int defParserlineno=1;
 217
 218 unsigned char* defToken_string_buf = new unsigned char[1024];
 219 int defToken_string_buf_size = 1024;
 220 int defToken_string_buf_content_size = 0;
 221
 222 unsigned char* new_copy(const unsigned char* str, int size)
 223 {
 224    unsigned char* x = new unsigned char[ ( size <= 0 ) ? 1 : size + 1];
 225    memcpy(x, str, size);
 226    x[size] = 0;
 227    return x;
 228 }
 229
 230 void addToDefTokenStringBuf(const unsigned char* str, int size)
 231 {
 232    if ( size <= 0 ) return;
 233
 234    if ( defToken_string_buf_size - defToken_string_buf_content_size < size ) {
 235       defToken_string_buf_size = 2*(size+defToken_string_buf_content_size);
 236       unsigned char* x = new unsigned char[defToken_string_buf_size];
 237       memcpy(x, defToken_string_buf, defToken_string_buf_content_size);
 238       delete defToken_string_buf;
 239       defToken_string_buf = x;
 240    }
 241
 242    memcpy(defToken_string_buf + defToken_string_buf_content_size, str, size);
 243    defToken_string_buf_content_size += size;
 244    defToken_string_buf[defToken_string_buf_content_size] = 0;
 245 }
 246
 247
 248
 249 #define quoted_string 1
 250 # line 74 "defToken.l"
 251
 252 /* done after the current pattern has been matched and before the
 253  * corresponding action - sets up defParsertext
 254  */
 255 #define defParser_DO_BEFORE_ACTION \
 256         defParsertext = defParser_bp; \
 257         defParserleng = defParser_cp - defParser_bp; \
 258         defParser_hold_char = *defParser_cp; \
 259         *defParser_cp = '\0'; \
 260         defParser_c_buf_p = defParser_cp;
 261
 262 #define EOB_ACT_CONTINUE_SCAN 0
 263 #define EOB_ACT_END_OF_FILE 1
 264 #define EOB_ACT_LAST_MATCH 2
 265
 266 /* return all but the first 'n' matched characters back to the input stream */
 267 #define defParserless(n) \
 268         do \
 269                 { \
 270                 /* undo effects of setting up defParsertext */ \
 271                 *defParser_cp = defParser_hold_char; \
 272                 defParser_c_buf_p = defParser_cp = defParser_bp + n; \
 273                 defParser_DO_BEFORE_ACTION; /* set up defParsertext again */ \
 274                 } \
 275         while ( 0 )
 276
 277 #define unput(c) defParserunput( c, defParsertext )
 278
 279
 280 struct defParser_buffer_state
 281     {
 282     FILE *defParser_input_file;
 283
 284     defParser_CHAR *defParser_ch_buf;           /* input buffer */
 285     defParser_CHAR *defParser_buf_pos;  /* current position in input buffer */
 286
 287     /* size of input buffer in bytes, not including room for EOB characters*/
 288     int defParser_buf_size;
 289
 290     /* number of characters read into defParser_ch_buf, not including EOB characters */
 291     int defParser_n_chars;
 292
 293     int defParser_eof_status;           /* whether we've seen an EOF on this buffer */
 294 #define EOF_NOT_SEEN 0
 295     /* "pending" happens when the EOF has been seen but there's still
 296      * some text process
 297      */
 298 #define EOF_PENDING 1
 299 #define EOF_DONE 2
 300     };
 301
 302 static defParser_BUFFER_STATE defParser_current_buffer;
 303
 304 /* we provide macros for accessing buffer states in case in the
 305  * future we want to put the buffer states in a more general
 306  * "scanner state"
 307  */
 308 #define defParser_CURRENT_BUFFER defParser_current_buffer
 309
 310
 311 /* defParser_hold_char holds the character lost when defParsertext is formed */
 312 static defParser_CHAR defParser_hold_char;
 313
 314 static int defParser_n_chars;           /* number of characters read into defParser_ch_buf */
 315
 316
 317
 318 #ifndef defParser_USER_ACTION
 319 #define defParser_USER_ACTION
 320 #endif
 321
 322 #ifndef defParser_USER_INIT
 323 #define defParser_USER_INIT
 324 #endif
 325
 326 extern defParser_CHAR *defParsertext;
 327 extern int defParserleng;
 328 extern FILE *defParserin, *defParserout;
 329
 330 defParser_CHAR *defParsertext;
 331 int defParserleng;
 332
 333 FILE *defParserin = (FILE *) 0, *defParserout = (FILE *) 0;
 334
 335 #define defParser_END_OF_BUFFER 29
 336 typedef int defParser_state_type;
 337 static const short int defParser_accept[84] =
 338     {   0,
 339         0,    0,    0,    0,   29,   24,   25,   26,   27,   20,
 340        24,    8,    9,    3,    2,   18,    5,    4,   24,   24,
 341        24,   24,   24,   24,    6,    7,    1,   22,   28,   21,
 342        24,   23,    0,   18,   24,   24,   24,   24,   24,   24,
 343         1,    1,   19,   24,   24,   24,   24,   24,   24,   24,
 344        24,   24,   24,   13,   24,   16,   24,   24,   24,   24,
 345        24,   24,   24,   11,   17,   24,   12,   24,   24,   24,
 346        14,   24,   24,   24,   24,   24,   24,   24,   24,   10,
 347        24,   15,    0
 348     } ;
 349
 350 static const defParser_CHAR defParser_ec[256] =
 351     {   0,
 352         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 353         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 354         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 355         1,    4,    1,    5,    6,    1,    1,    7,    1,    8,
 356         9,   10,    4,   11,    1,   12,    4,   13,   13,   13,
 357        13,   13,   13,   13,   13,   13,   13,   14,   15,    1,
 358         4,    1,    4,    4,   16,   17,    1,   18,   19,   20,
 359        21,    1,   22,    1,    1,   23,   24,   25,   26,   27,
 360         1,   28,   29,   30,    1,    1,    1,   31,   32,    1,
 361         4,    1,    4,    4,   33,    1,   16,   17,    1,   18,
 362
 363        19,   20,   21,    1,   22,    1,    1,   23,   24,   25,
 364        26,   27,    1,   28,   29,   30,    1,    1,    1,   31,
 365        32,    1,   34,    1,   35,    1,    1,    1,    1,    1,
 366         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 367         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 368         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 369         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 370         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 371         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 372         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 373
 374         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 375         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 376         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 377         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 378         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 379         1,    1,    1,    1,    1
 380     } ;
 381
 382 static const defParser_CHAR defParser_meta[36] =
 383     {   0,
 384         1,    2,    3,    2,    2,    1,    1,    2,    2,    2,
 385         2,    2,    1,    2,    2,    1,    1,    1,    1,    1,
 386         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 387         1,    1,    1,    2,    2
 388     } ;
 389
 390 static const short int defParser_base[89] =
 391     {   0,
 392         0,  119,   33,   34,  124,    0,  126,  126,  126,  126,
 393         0,  126,  126,  126,  126,   28,  126,  126,   95,   96,
 394        99,   95,  100,   88,  126,  126,   40,  126,  126,  126,
 395         0,    0,  104,   34,   79,   80,   81,   74,   87,   74,
 396        74,    0,   88,   84,   76,   79,   78,   73,   73,   62,
 397        74,   67,   70,    0,   65,    0,   71,   52,   61,   56,
 398        48,   50,   43,   37,    0,   43,    0,   41,   42,   38,
 399        32,   45,   36,   42,   39,   38,   28,   27,   38,    0,
 400        33,    0,  126,  109,   52,   42,  112,  114
 401     } ;
 402
 403 static const short int defParser_def[89] =
 404     {   0,
 405        83,    1,   84,   84,   83,   85,   83,   83,   83,   83,
 406        86,   83,   83,   83,   83,   85,   83,   83,   85,   85,
 407        85,   85,   85,   85,   83,   83,   87,   83,   83,   83,
 408        85,   86,   83,   85,   85,   85,   85,   85,   85,   85,
 409        87,   88,   83,   85,   85,   85,   85,   85,   85,   85,
 410        85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
 411        85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
 412        85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
 413        85,   85,    0,   83,   83,   83,   83,   83
 414     } ;
 415
 416 static const short int defParser_nxt[162] =
 417     {   0,
 418         6,    7,    8,    9,   10,    6,   11,   12,   13,   14,
 419        15,    9,   16,   17,   18,   19,   20,   21,    6,    6,
 420         6,   22,    6,    6,    6,    6,    6,   23,   24,    6,
 421         6,    6,    6,   25,   26,   29,   29,   30,   30,   33,
 422        34,   42,   32,   42,   42,   33,   34,   42,   42,   42,
 423        42,   42,   31,   42,   42,   82,   81,   80,   79,   78,
 424        77,   76,   75,   74,   73,   72,   71,   70,   69,   68,
 425        67,   66,   65,   42,   42,   42,   64,   42,   42,   63,
 426        62,   42,   42,   42,   42,   42,   61,   42,   42,   60,
 427        59,   58,   57,   56,   55,   54,   53,   52,   51,   50,
 428
 429        43,   49,   48,   47,   46,   45,   44,   42,   42,   28,
 430        28,   28,   41,   41,   42,   42,   43,   40,   39,   38,
 431        37,   36,   35,   83,   27,    5,   83,   83,   83,   83,
 432        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 433        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 434        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 435        83
 436     } ;
 437
 438 static const short int defParser_chk[162] =
 439     {   0,
 440         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 441         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 442         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 443         1,    1,    1,    1,    1,    3,    4,    3,    4,   16,
 444        16,   27,   86,   27,   27,   34,   34,   27,   27,   27,
 445        27,   27,   85,   27,   27,   81,   79,   78,   77,   76,
 446        75,   74,   73,   72,   71,   70,   69,   68,   66,   64,
 447        63,   62,   61,   27,   27,   41,   60,   41,   41,   59,
 448        58,   41,   41,   41,   41,   41,   57,   41,   41,   55,
 449        53,   52,   51,   50,   49,   48,   47,   46,   45,   44,
 450
 451        43,   40,   39,   38,   37,   36,   35,   41,   41,   84,
 452        84,   84,   87,   87,   88,   88,   33,   24,   23,   22,
 453        21,   20,   19,    5,    2,   83,   83,   83,   83,   83,
 454        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 455        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 456        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 457        83
 458     } ;
 459
 460 static defParser_state_type defParser_last_accepting_state;
 461 static defParser_CHAR *defParser_last_accepting_cpos;
 462
 463 /* the intent behind this definition is that it'll catch
 464  * any uses of REJECT which flex missed
 465  */
 466 #define REJECT reject_used_but_not_detected
 467 #define defParsermore() defParsermore_used_but_not_detected
 468 #define defParser_MORE_ADJ 0
 469
 470 /* these variables are all declared out here so that section 3 code can
 471  * manipulate them
 472  */
 473 /* points to current character in buffer */
 474 static defParser_CHAR *defParser_c_buf_p = (defParser_CHAR *) 0;
 475 static int defParser_init = 1;          /* whether we need to initialize */
 476 static int defParser_start = 0; /* start state number */
 477
 478 /* flag which is used to allow defParserwrap()'s to do buffer switches
 479  * instead of setting up a fresh defParserin.  A bit of a hack ...
 480  */
 481 static int defParser_did_buffer_switch_on_eof;
 482
 483 static defParser_state_type defParser_get_previous_state defParser_PROTO(( void ));
 484 static defParser_state_type defParser_try_NUL_trans defParser_PROTO(( defParser_state_type current_state ));
 485 static int defParser_get_next_buffer defParser_PROTO(( void ));
 486 #if 0
 487 static void defParserunput defParser_PROTO(( defParser_CHAR c, defParser_CHAR *buf_ptr ));
 488 #endif
 489 void defParserrestart defParser_PROTO(( FILE *input_file ));
 490 void defParser_switch_to_buffer defParser_PROTO(( defParser_BUFFER_STATE new_buffer ));
 491 void defParser_load_buffer_state defParser_PROTO(( void ));
 492 defParser_BUFFER_STATE defParser_create_buffer defParser_PROTO(( FILE *file, int size ));
 493 void defParser_delete_buffer defParser_PROTO(( defParser_BUFFER_STATE b ));
 494 void defParser_init_buffer defParser_PROTO(( defParser_BUFFER_STATE b, FILE *file ));
 495
 496 #define defParser_new_buffer defParser_create_buffer
 497
 498 #if 0
 499 #ifdef __cplusplus
 500 static int defParserinput defParser_PROTO(( void ));
 501 #else
 502 static int input defParser_PROTO(( void ));
 503 #endif
 504 #endif
 505
 506 defParser_DECL
 507     {
 508     register defParser_state_type defParser_current_state;
 509     register defParser_CHAR *defParser_cp, *defParser_bp;
 510     register int defParser_act;
 511
 512
 513
 514
 515     if ( defParser_init )
 516         {
 517         defParser_USER_INIT;
 518
 519         if ( ! defParser_start )
 520             defParser_start = 1;        /* first start state */
 521
 522         if ( ! defParserin )
 523             defParserin = stdin;
 524
 525         if ( ! defParserout )
 526             defParserout = stdout;
 527
 528         if ( defParser_current_buffer )
 529             defParser_init_buffer( defParser_current_buffer, defParserin );
 530         else
 531             defParser_current_buffer = defParser_create_buffer( defParserin, defParser_BUF_SIZE );
 532
 533         defParser_load_buffer_state();
 534
 535         defParser_init = 0;
 536         }
 537
 538     while ( 1 )         /* loops until end-of-file is reached */
 539         {
 540         defParser_cp = defParser_c_buf_p;
 541
 542         /* support of defParsertext */
 543         *defParser_cp = defParser_hold_char;
 544
 545         /* defParser_bp points to the position in defParser_ch_buf of the start of the
 546          * current run.
 547          */
 548         defParser_bp = defParser_cp;
 549
 550         defParser_current_state = defParser_start;
 551         if ( defParser_bp[-1] == '\n' )
 552             ++defParser_current_state;
 553 defParser_match:
 554         do
 555             {
 556             register defParser_CHAR defParser_c = defParser_ec[*defParser_cp];
 557             if ( defParser_accept[defParser_current_state] )
 558                 {
 559                 defParser_last_accepting_state = defParser_current_state;
 560                 defParser_last_accepting_cpos = defParser_cp;
 561                 }
 562             while ( defParser_chk[defParser_base[defParser_current_state] + defParser_c] != defParser_current_state )
 563                 {
 564                 defParser_current_state = defParser_def[defParser_current_state];
 565                 if ( defParser_current_state >= 84 )
 566                     defParser_c = defParser_meta[defParser_c];
 567                 }
 568             defParser_current_state = defParser_nxt[defParser_base[defParser_current_state] + defParser_c];
 569             ++defParser_cp;
 570             }
 571         while ( defParser_current_state != 83 );
 572         defParser_cp = defParser_last_accepting_cpos;
 573         defParser_current_state = defParser_last_accepting_state;
 574
 575 defParser_find_action:
 576         defParser_act = defParser_accept[defParser_current_state];
 577
 578         defParser_DO_BEFORE_ACTION;
 579         defParser_USER_ACTION;
 580
 581 do_action:      /* this label is used only to access EOF actions */
 582
 583
 584         switch ( defParser_act )
 585             {
 586             case 0: /* must backtrack */
 587             /* undo the effects of defParser_DO_BEFORE_ACTION */
 588             *defParser_cp = defParser_hold_char;
 589             defParser_cp = defParser_last_accepting_cpos;
 590             defParser_current_state = defParser_last_accepting_state;
 591             goto defParser_find_action;
 592
 593 case 1:
 594 # line 76 "defToken.l"
 595 {
 596         }
 597         defParser_BREAK
 598 case 2:
 599 # line 79 "defToken.l"
 600 {
 601            return(COMMA);
 602         }
 603         defParser_BREAK
 604 case 3:
 605 # line 83 "defToken.l"
 606 {
 607            return(STAR);
 608         }
 609         defParser_BREAK
 610 case 4:
 611 # line 87 "defToken.l"
 612 {
 613            return(SEMI_COLON);
 614         }
 615         defParser_BREAK
 616 case 5:
 617 # line 91 "defToken.l"
 618 {
 619            return(COLON);
 620         }
 621         defParser_BREAK
 622 case 6:
 623 # line 95 "defToken.l"
 624 {
 625            return(FSOPEN);
 626         }
 627         defParser_BREAK
 628 case 7:
 629 # line 99 "defToken.l"
 630 {
 631            return(FSCLOSE);
 632         }
 633         defParser_BREAK
 634 case 8:
 635 # line 103 "defToken.l"
 636 {
 637            return(OPER_parenopen);
 638         }
 639         defParser_BREAK
 640 case 9:
 641 # line 107 "defToken.l"
 642 {
 643            return(OPER_parenclose);
 644         }
 645         defParser_BREAK
 646 case 10:
 647 # line 112 "defToken.l"
 648 {
 649                 defParserlval.charPtrData = new_copy((unsigned char*)defParsertext, defParserleng);
 650                 return(TYPE);
 651         }
 652         defParser_BREAK
 653 case 11:
 654 # line 117 "defToken.l"
 655 {
 656                 defParserlval.charPtrData = new_copy((unsigned char*)defParsertext, defParserleng);
 657                 return(TYPE);
 658         }
 659         defParser_BREAK
 660 case 12:
 661 # line 122 "defToken.l"
 662 {
 663                 defParserlval.charPtrData = new_copy((unsigned char*)defParsertext, defParserleng);
 664                 return(TYPE);
 665         }
 666         defParser_BREAK
 667 case 13:
 668 # line 127 "defToken.l"
 669 {
 670                 defParserlval.charPtrData = new_copy((unsigned char*)defParsertext, defParserleng);
 671                 return(TYPE);
 672         }
 673         defParser_BREAK
 674 case 14:
 675 # line 132 "defToken.l"
 676 {
 677                 defParserlval.charPtrData = new_copy((unsigned char*)defParsertext, defParserleng);
 678                 return(TYPE);
 679         }
 680         defParser_BREAK
 681 case 15:
 682 # line 137 "defToken.l"
 683 {
 684                 defParserlval.charPtrData = new_copy((unsigned char*)defParsertext, defParserleng);
 685                 return(TYPE);
 686         }
 687         defParser_BREAK
 688 case 16:
 689 # line 142 "defToken.l"
 690 {
 691                 defParserlval.charPtrData = new_copy((unsigned char*)defParsertext, defParserleng);
 692                 return(TYPE);
 693         }
 694         defParser_BREAK
 695 case 17:
 696 # line 147 "defToken.l"
 697 {
 698                 defParserlval.charPtrData =
 699                       new_copy((unsigned char*)"INTEGER", strlen("INTEGER"));
 700                 return(TYPE);
 701         }
 702         defParser_BREAK
 703 case 18:
 704 # line 153 "defToken.l"
 705 {
 706                 defParserlval.intData = atoi((char*)defParsertext);
 707                 return(INTEGER);
 708                 }
 709         defParser_BREAK
 710 case 19:
 711 # line 158 "defToken.l"
 712 {
 713                 defParserlval.realData = atof((char*)defParsertext);
 714                 return(REAL);
 715                 }
 716         defParser_BREAK
 717 case 20:
 718 # line 163 "defToken.l"
 719 {
 720                 BEGIN quoted_string;
 721                 }
 722         defParser_BREAK
 723 case 21:
 724 # line 167 "defToken.l"
 725 {
 726
 727                 defParserlval.charPtrData =
 728                         new unsigned char[defToken_string_buf_content_size+1];
 729                 memcpy( defParserlval.charPtrData,
 730                         defToken_string_buf,
 731                         defToken_string_buf_content_size+1
 732                       );
 733
 734                 defToken_string_buf_content_size = 0;
 735                 BEGIN 0;
 736
 737                 return(QUOTED_STRING);
 738                 }
 739         defParser_BREAK
 740 case 22:
 741 # line 182 "defToken.l"
 742 {
 743                 addToDefTokenStringBuf((const unsigned char *)defParsertext, defParserleng);
 744                 }
 745         defParser_BREAK
 746 case 23:
 747 # line 186 "defToken.l"
 748 {
 749                 defParserlval.charPtrData =
 750                   (unsigned char*)strdup((const char*)(defParsertext+1));
 751                 return(REF_NAME);
 752                 }
 753         defParser_BREAK
 754 case 24:
 755 # line 192 "defToken.l"
 756 {
 757                 defParserlval.charPtrData =
 758                   (unsigned char*)strdup((const char*)defParsertext);
 759                 return(NORMAL_STRING);
 760                 }
 761         defParser_BREAK
 762 case 25:
 763 # line 198 "defToken.l"
 764 {
 765         }
 766         defParser_BREAK
 767 case 26:
 768 # line 201 "defToken.l"
 769 {
 770            defParserlineno++;
 771         }
 772         defParser_BREAK
 773 case 27:
 774 # line 205 "defToken.l"
 775 {
 776         }
 777         defParser_BREAK
 778 case 28:
 779 # line 210 "defToken.l"
 780 defParser_FATAL_ERROR( "flex scanner jammed" );
 781         defParser_BREAK
 782 case defParser_STATE_EOF(INITIAL):
 783 case defParser_STATE_EOF(quoted_string):
 784     defParserterminate();
 785
 786             case defParser_END_OF_BUFFER:
 787                 {
 788                 /* amount of text matched not including the EOB char */
 789                 int defParser_amount_of_matched_text = defParser_cp - defParsertext - 1;
 790
 791                 /* undo the effects of defParser_DO_BEFORE_ACTION */
 792                 *defParser_cp = defParser_hold_char;
 793
 794                 /* note that here we test for defParser_c_buf_p "<=" to the position
 795                  * of the first EOB in the buffer, since defParser_c_buf_p will
 796                  * already have been incremented past the NUL character
 797                  * (since all states make transitions on EOB to the end-
 798                  * of-buffer state).  Contrast this with the test in defParserinput().
 799                  */
 800                 if ( defParser_c_buf_p <= &defParser_current_buffer->defParser_ch_buf[defParser_n_chars] )
 801                     /* this was really a NUL */
 802                     {
 803                     defParser_state_type defParser_next_state;
 804
 805                     defParser_c_buf_p = defParsertext + defParser_amount_of_matched_text;
 806
 807                     defParser_current_state = defParser_get_previous_state();
 808
 809                     /* okay, we're now positioned to make the
 810                      * NUL transition.  We couldn't have
 811                      * defParser_get_previous_state() go ahead and do it
 812                      * for us because it doesn't know how to deal
 813                      * with the possibility of jamming (and we
 814                      * don't want to build jamming into it because
 815                      * then it will run more slowly)
 816                      */
 817
 818                     defParser_next_state = defParser_try_NUL_trans( defParser_current_state );
 819
 820                     defParser_bp = defParsertext + defParser_MORE_ADJ;
 821
 822                     if ( defParser_next_state )
 823                         {
 824                         /* consume the NUL */
 825                         defParser_cp = ++defParser_c_buf_p;
 826                         defParser_current_state = defParser_next_state;
 827                         goto defParser_match;
 828                         }
 829
 830                     else
 831                         {
 832                             defParser_cp = defParser_last_accepting_cpos;
 833                             defParser_current_state = defParser_last_accepting_state;
 834                         goto defParser_find_action;
 835                         }
 836                     }
 837
 838                 else switch ( defParser_get_next_buffer() )
 839                     {
 840                     case EOB_ACT_END_OF_FILE:
 841                         {
 842                         defParser_did_buffer_switch_on_eof = 0;
 843
 844                         if ( defParserwrap() )
 845                             {
 846                             /* note: because we've taken care in
 847                              * defParser_get_next_buffer() to have set up defParsertext,
 848                              * we can now set up defParser_c_buf_p so that if some
 849                              * total hoser (like flex itself) wants
 850                              * to call the scanner after we return the
 851                              * defParser_NULL, it'll still work - another defParser_NULL
 852                              * will get returned.
 853                              */
 854                             defParser_c_buf_p = defParsertext + defParser_MORE_ADJ;
 855
 856                             defParser_act = defParser_STATE_EOF((defParser_start - 1) / 2);
 857                             goto do_action;
 858                             }
 859
 860                         else
 861                             {
 862                             if ( ! defParser_did_buffer_switch_on_eof )
 863                                 defParser_NEW_FILE;
 864                             }
 865                         }
 866                         break;
 867
 868                     case EOB_ACT_CONTINUE_SCAN:
 869                         defParser_c_buf_p = defParsertext + defParser_amount_of_matched_text;
 870
 871                         defParser_current_state = defParser_get_previous_state();
 872
 873                         defParser_cp = defParser_c_buf_p;
 874                         defParser_bp = defParsertext + defParser_MORE_ADJ;
 875                         goto defParser_match;
 876
 877                     case EOB_ACT_LAST_MATCH:
 878                         defParser_c_buf_p =
 879                             &defParser_current_buffer->defParser_ch_buf[defParser_n_chars];
 880
 881                         defParser_current_state = defParser_get_previous_state();
 882
 883                         defParser_cp = defParser_c_buf_p;
 884                         defParser_bp = defParsertext + defParser_MORE_ADJ;
 885                         goto defParser_find_action;
 886                     }
 887                 break;
 888                 }
 889
 890             default:
 891 #ifdef FLEX_DEBUG
 892                 printf( "action # %d\n", defParser_act );
 893 #endif
 894                 defParser_FATAL_ERROR(
 895                         "fatal flex scanner internal error--no action found" );
 896             }
 897         }
 898     }
 899
 900
 901 /* defParser_get_next_buffer - try to read in a new buffer
 902  *
 903  * synopsis
 904  *     int defParser_get_next_buffer();
 905  *
 906  * returns a code representing an action
 907  *     EOB_ACT_LAST_MATCH -
 908  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 909  *     EOB_ACT_END_OF_FILE - end of file
 910  */
 911
 912 static int defParser_get_next_buffer()
 913
 914     {
 915     register defParser_CHAR *dest = defParser_current_buffer->defParser_ch_buf;
 916     register defParser_CHAR *source = defParsertext - 1; /* copy prev. char, too */
 917     register int number_to_move, i;
 918     int ret_val;
 919
 920     if ( defParser_c_buf_p > &defParser_current_buffer->defParser_ch_buf[defParser_n_chars + 1] )
 921         defParser_FATAL_ERROR(
 922                 "fatal flex scanner internal error--end of buffer missed" );
 923
 924     /* try to read more data */
 925
 926     /* first move last chars to start of buffer */
 927     number_to_move = defParser_c_buf_p - defParsertext;
 928
 929     for ( i = 0; i < number_to_move; ++i )
 930         *(dest++) = *(source++);
 931
 932     if ( defParser_current_buffer->defParser_eof_status != EOF_NOT_SEEN )
 933         /* don't do the read, it's not guaranteed to return an EOF,
 934          * just force an EOF
 935          */
 936         defParser_n_chars = 0;
 937
 938     else
 939         {
 940         int num_to_read = defParser_current_buffer->defParser_buf_size - number_to_move - 1;
 941
 942         if ( num_to_read > defParser_READ_BUF_SIZE )
 943             num_to_read = defParser_READ_BUF_SIZE;
 944
 945         else if ( num_to_read <= 0 )
 946             defParser_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
 947
 948         /* read in more data */
 949         defParser_INPUT( (&defParser_current_buffer->defParser_ch_buf[number_to_move]),
 950                   defParser_n_chars, num_to_read );
 951         }
 952
 953     if ( defParser_n_chars == 0 )
 954         {
 955         if ( number_to_move == 1 )
 956             {
 957             ret_val = EOB_ACT_END_OF_FILE;
 958             defParser_current_buffer->defParser_eof_status = EOF_DONE;
 959             }
 960
 961         else
 962             {
 963             ret_val = EOB_ACT_LAST_MATCH;
 964             defParser_current_buffer->defParser_eof_status = EOF_PENDING;
 965             }
 966         }
 967
 968     else
 969         ret_val = EOB_ACT_CONTINUE_SCAN;
 970
 971     defParser_n_chars += number_to_move;
 972     defParser_current_buffer->defParser_ch_buf[defParser_n_chars] = defParser_END_OF_BUFFER_CHAR;
 973     defParser_current_buffer->defParser_ch_buf[defParser_n_chars + 1] = defParser_END_OF_BUFFER_CHAR;
 974
 975     /* defParsertext begins at the second character in defParser_ch_buf; the first
 976      * character is the one which preceded it before reading in the latest
 977      * buffer; it needs to be kept around in case it's a newline, so
 978      * defParser_get_previous_state() will have with '^' rules active
 979      */
 980
 981     defParsertext = &defParser_current_buffer->defParser_ch_buf[1];
 982
 983     return ( ret_val );
 984     }
 985
 986
 987 /* defParser_get_previous_state - get the state just before the EOB char was reached
 988  *
 989  * synopsis
 990  *     defParser_state_type defParser_get_previous_state();
 991  */
 992
 993 static defParser_state_type defParser_get_previous_state()
 994
 995     {
 996     register defParser_state_type defParser_current_state;
 997     register defParser_CHAR *defParser_cp;
 998
 999     register defParser_CHAR *defParser_bp = defParsertext;
1000
1001     defParser_current_state = defParser_start;
1002     if ( defParser_bp[-1] == '\n' )
1003         ++defParser_current_state;
1004
1005     for ( defParser_cp = defParsertext + defParser_MORE_ADJ; defParser_cp < defParser_c_buf_p; ++defParser_cp )
1006         {
1007         register defParser_CHAR defParser_c = (*defParser_cp ? defParser_ec[*defParser_cp] : 1);
1008         if ( defParser_accept[defParser_current_state] )
1009             {
1010             defParser_last_accepting_state = defParser_current_state;
1011             defParser_last_accepting_cpos = defParser_cp;
1012             }
1013         while ( defParser_chk[defParser_base[defParser_current_state] + defParser_c] != defParser_current_state )
1014             {
1015             defParser_current_state = defParser_def[defParser_current_state];
1016             if ( defParser_current_state >= 84 )
1017                 defParser_c = defParser_meta[defParser_c];
1018             }
1019         defParser_current_state = defParser_nxt[defParser_base[defParser_current_state] + defParser_c];
1020         }
1021
1022     return ( defParser_current_state );
1023     }
1024
1025
1026 /* defParser_try_NUL_trans - try to make a transition on the NUL character
1027  *
1028  * synopsis
1029  *     next_state = defParser_try_NUL_trans( current_state );
1030  */
1031
1032 #ifdef defParser_USE_PROTOS
1033 static defParser_state_type defParser_try_NUL_trans( register defParser_state_type defParser_current_state )
1034 #else
1035 static defParser_state_type defParser_try_NUL_trans( defParser_current_state )
1036 register defParser_state_type defParser_current_state;
1037 #endif
1038
1039     {
1040     register int defParser_is_jam;
1041     register defParser_CHAR *defParser_cp = defParser_c_buf_p;
1042
1043     register defParser_CHAR defParser_c = 1;
1044     if ( defParser_accept[defParser_current_state] )
1045         {
1046         defParser_last_accepting_state = defParser_current_state;
1047         defParser_last_accepting_cpos = defParser_cp;
1048         }
1049     while ( defParser_chk[defParser_base[defParser_current_state] + defParser_c] != defParser_current_state )
1050         {
1051         defParser_current_state = defParser_def[defParser_current_state];
1052         if ( defParser_current_state >= 84 )
1053             defParser_c = defParser_meta[defParser_c];
1054         }
1055     defParser_current_state = defParser_nxt[defParser_base[defParser_current_state] + defParser_c];
1056     defParser_is_jam = (defParser_current_state == 83);
1057
1058     return ( defParser_is_jam ? 0 : defParser_current_state );
1059     }
1060
1061
1062 #if 0
1063 #ifdef defParser_USE_PROTOS
1064 static void defParserunput( defParser_CHAR c, register defParser_CHAR *defParser_bp )
1065 #else
1066 static void defParserunput( c, defParser_bp )
1067 defParser_CHAR c;
1068 register defParser_CHAR *defParser_bp;
1069 #endif
1070
1071     {
1072     register defParser_CHAR *defParser_cp = defParser_c_buf_p;
1073
1074     /* undo effects of setting up defParsertext */
1075     *defParser_cp = defParser_hold_char;
1076
1077     if ( defParser_cp < defParser_current_buffer->defParser_ch_buf + 2 )
1078         { /* need to shift things up to make room */
1079         register int number_to_move = defParser_n_chars + 2; /* +2 for EOB chars */
1080         register defParser_CHAR *dest =
1081             &defParser_current_buffer->defParser_ch_buf[defParser_current_buffer->defParser_buf_size + 2];
1082         register defParser_CHAR *source =
1083             &defParser_current_buffer->defParser_ch_buf[number_to_move];
1084
1085         while ( source > defParser_current_buffer->defParser_ch_buf )
1086             *--dest = *--source;
1087
1088         defParser_cp += dest - source;
1089         defParser_bp += dest - source;
1090         defParser_n_chars = defParser_current_buffer->defParser_buf_size;
1091
1092         if ( defParser_cp < defParser_current_buffer->defParser_ch_buf + 2 )
1093             defParser_FATAL_ERROR( "flex scanner push-back overflow" );
1094         }
1095
1096     if ( defParser_cp > defParser_bp && defParser_cp[-1] == '\n' )
1097         defParser_cp[-2] = '\n';
1098
1099     *--defParser_cp = c;
1100
1101     /* note: the formal parameter *must* be called "defParser_bp" for this
1102      *       macro to now work correctly
1103      */
1104     defParser_DO_BEFORE_ACTION; /* set up defParsertext again */
1105     }
1106 #endif
1107
1108
1109 #if 0
1110 #ifdef __cplusplus
1111 static int defParserinput()
1112 #else
1113 static int input()
1114 #endif
1115
1116     {
1117     int c;
1118     defParser_CHAR *defParser_cp = defParser_c_buf_p;
1119
1120     *defParser_cp = defParser_hold_char;
1121
1122     if ( *defParser_c_buf_p == defParser_END_OF_BUFFER_CHAR )
1123         {
1124         /* defParser_c_buf_p now points to the character we want to return.
1125          * If this occurs *before* the EOB characters, then it's a
1126          * valid NUL; if not, then we've hit the end of the buffer.
1127          */
1128         if ( defParser_c_buf_p < &defParser_current_buffer->defParser_ch_buf[defParser_n_chars] )
1129             /* this was really a NUL */
1130             *defParser_c_buf_p = '\0';
1131
1132         else
1133             { /* need more input */
1134             defParsertext = defParser_c_buf_p;
1135             ++defParser_c_buf_p;
1136
1137             switch ( defParser_get_next_buffer() )
1138                 {
1139                 case EOB_ACT_END_OF_FILE:
1140                     {
1141                     if ( defParserwrap() )
1142                         {
1143                         defParser_c_buf_p = defParsertext + defParser_MORE_ADJ;
1144                         return ( EOF );
1145                         }
1146
1147                     defParser_NEW_FILE;
1148
1149 #ifdef __cplusplus
1150                     return ( defParserinput() );
1151 #else
1152                     return ( input() );
1153 #endif
1154                     }
1155                     break;
1156
1157                 case EOB_ACT_CONTINUE_SCAN:
1158                     defParser_c_buf_p = defParsertext + defParser_MORE_ADJ;
1159                     break;
1160
1161                 case EOB_ACT_LAST_MATCH:
1162 #ifdef __cplusplus
1163                     defParser_FATAL_ERROR( "unexpected last match in defParserinput()" );
1164 #else
1165                     defParser_FATAL_ERROR( "unexpected last match in input()" );
1166 #endif
1167                 }
1168             }
1169         }
1170
1171     c = *defParser_c_buf_p;
1172     defParser_hold_char = *++defParser_c_buf_p;
1173
1174     return ( c );
1175     }
1176 #endif
1177
1178
1179 #ifdef defParser_USE_PROTOS
1180 void defParserrestart( FILE *input_file )
1181 #else
1182 void defParserrestart( input_file )
1183 FILE *input_file;
1184 #endif
1185
1186     {
1187     defParser_init_buffer( defParser_current_buffer, input_file );
1188     defParser_load_buffer_state();
1189     }
1190
1191
1192 #ifdef defParser_USE_PROTOS
1193 void defParser_switch_to_buffer( defParser_BUFFER_STATE new_buffer )
1194 #else
1195 void defParser_switch_to_buffer( new_buffer )
1196 defParser_BUFFER_STATE new_buffer;
1197 #endif
1198
1199     {
1200     if ( defParser_current_buffer == new_buffer )
1201         return;
1202
1203     if ( defParser_current_buffer )
1204         {
1205         /* flush out information for old buffer */
1206         *defParser_c_buf_p = defParser_hold_char;
1207         defParser_current_buffer->defParser_buf_pos = defParser_c_buf_p;
1208         defParser_current_buffer->defParser_n_chars = defParser_n_chars;
1209         }
1210
1211     defParser_current_buffer = new_buffer;
1212     defParser_load_buffer_state();
1213
1214     /* we don't actually know whether we did this switch during
1215      * EOF (defParserwrap()) processing, but the only time this flag
1216      * is looked at is after defParserwrap() is called, so it's safe
1217      * to go ahead and always set it.
1218      */
1219     defParser_did_buffer_switch_on_eof = 1;
1220     }
1221
1222
1223 #ifdef defParser_USE_PROTOS
1224 void defParser_load_buffer_state( void )
1225 #else
1226 void defParser_load_buffer_state()
1227 #endif
1228
1229     {
1230     defParser_n_chars = defParser_current_buffer->defParser_n_chars;
1231     defParsertext = defParser_c_buf_p = defParser_current_buffer->defParser_buf_pos;
1232     defParserin = defParser_current_buffer->defParser_input_file;
1233     defParser_hold_char = *defParser_c_buf_p;
1234     }
1235
1236
1237 #ifdef defParser_USE_PROTOS
1238 defParser_BUFFER_STATE defParser_create_buffer( FILE *file, int size )
1239 #else
1240 defParser_BUFFER_STATE defParser_create_buffer( file, size )
1241 FILE *file;
1242 int size;
1243 #endif
1244
1245     {
1246     defParser_BUFFER_STATE b;
1247
1248     b = (defParser_BUFFER_STATE) malloc( sizeof( struct defParser_buffer_state ) );
1249
1250     if ( ! b )
1251         defParser_FATAL_ERROR( "out of dynamic memory in defParser_create_buffer()" );
1252
1253     b->defParser_buf_size = size;
1254
1255     /* defParser_ch_buf has to be 2 characters longer than the size given because
1256      * we need to put in 2 end-of-buffer characters.
1257      */
1258     b->defParser_ch_buf = (defParser_CHAR *) malloc( (unsigned) (b->defParser_buf_size + 2) );
1259
1260     if ( ! b->defParser_ch_buf )
1261         defParser_FATAL_ERROR( "out of dynamic memory in defParser_create_buffer()" );
1262
1263     defParser_init_buffer( b, file );
1264
1265     return ( b );
1266     }
1267
1268
1269 #ifdef defParser_USE_PROTOS
1270 void defParser_delete_buffer( defParser_BUFFER_STATE b )
1271 #else
1272 void defParser_delete_buffer( b )
1273 defParser_BUFFER_STATE b;
1274 #endif
1275
1276     {
1277     if ( b == defParser_current_buffer )
1278         defParser_current_buffer = (defParser_BUFFER_STATE) 0;
1279
1280     free( (char *) b->defParser_ch_buf );
1281     free( (char *) b );
1282     }
1283
1284
1285 #ifdef defParser_USE_PROTOS
1286 void defParser_init_buffer( defParser_BUFFER_STATE b, FILE *file )
1287 #else
1288 void defParser_init_buffer( b, file )
1289 defParser_BUFFER_STATE b;
1290 FILE *file;
1291 #endif
1292
1293     {
1294     b->defParser_input_file = file;
1295
1296     /* we put in the '\n' and start reading from [1] so that an
1297      * initial match-at-newline will be true.
1298      */
1299
1300     b->defParser_ch_buf[0] = '\n';
1301     b->defParser_n_chars = 1;
1302
1303     /* we always need two end-of-buffer characters.  The first causes
1304      * a transition to the end-of-buffer state.  The second causes
1305      * a jam in that state.
1306      */
1307     b->defParser_ch_buf[1] = defParser_END_OF_BUFFER_CHAR;
1308     b->defParser_ch_buf[2] = defParser_END_OF_BUFFER_CHAR;
1309
1310     b->defParser_buf_pos = &b->defParser_ch_buf[1];
1311
1312     b->defParser_eof_status = EOF_NOT_SEEN;
1313     }
1314 # line 210 "defToken.l"
1315
1316
1317 void defParsererror(char* msg)
1318 {
1319    cerr << "line " << defParserlineno << ": " << msg;
1320 }
1321