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