src/tools/xmllexer.cc

   1 #define yy_create_buffer xmlParser_create_buffer
   2 #define yy_delete_buffer xmlParser_delete_buffer
   3 #define yy_scan_buffer xmlParser_scan_buffer
   4 #define yy_scan_string xmlParser_scan_string
   5 #define yy_scan_bytes xmlParser_scan_bytes
   6 #define yy_flex_debug xmlParser_flex_debug
   7 #define yy_init_buffer xmlParser_init_buffer
   8 #define yy_flush_buffer xmlParser_flush_buffer
   9 #define yy_load_buffer_state xmlParser_load_buffer_state
  10 #define yy_switch_to_buffer xmlParser_switch_to_buffer
  11 #define yyin xmlParserin
  12 #define yyleng xmlParserleng
  13 #define yylex xmlParserlex
  14 #define yyout xmlParserout
  15 #define yyrestart xmlParserrestart
  16 #define yytext xmlParsertext
  17
  18 #line 19 "xmllexer.cc"
  19 /* A lexical scanner generated by flex*/
  20
  21 /* Scanner skeleton version:
  22  * $Header: /cvsroot/gscpv4/src/tools/xmllexer.cc,v 1.1.1.1 2013/12/02 17:44:57 spatsch Exp $
  23  */
  24
  25 #define FLEX_SCANNER
  26 #define YY_FLEX_MAJOR_VERSION 2
  27 #define YY_FLEX_MINOR_VERSION 5
  28
  29 #include <stdio.h>
  30 #include <unistd.h>
  31
  32
  33 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  34 #ifdef c_plusplus
  35 #ifndef __cplusplus
  36 #define __cplusplus
  37 #endif
  38 #endif
  39
  40
  41 #ifdef __cplusplus
  42
  43 #include <stdlib.h>
  44
  45 /* Use prototypes in function declarations. */
  46 #define YY_USE_PROTOS
  47
  48 /* The "const" storage-class-modifier is valid. */
  49 #define YY_USE_CONST
  50
  51 #else   /* ! __cplusplus */
  52
  53 #if __STDC__
  54
  55 #define YY_USE_PROTOS
  56 #define YY_USE_CONST
  57
  58 #endif  /* __STDC__ */
  59 #endif  /* ! __cplusplus */
  60
  61 #ifdef __TURBOC__
  62  #pragma warn -rch
  63  #pragma warn -use
  64 #include <io.h>
  65 #include <stdlib.h>
  66 #define YY_USE_CONST
  67 #define YY_USE_PROTOS
  68 #endif
  69
  70 #ifdef YY_USE_CONST
  71 #define yyconst const
  72 #else
  73 #define yyconst
  74 #endif
  75
  76
  77 #ifdef YY_USE_PROTOS
  78 #define YY_PROTO(proto) proto
  79 #else
  80 #define YY_PROTO(proto) ()
  81 #endif
  82
  83 /* Returned upon end-of-file. */
  84 #define YY_NULL 0
  85
  86 /* Promotes a possibly negative, possibly signed char to an unsigned
  87  * integer for use as an array index.  If the signed char is negative,
  88  * we want to instead treat it as an 8-bit unsigned char, hence the
  89  * double cast.
  90  */
  91 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  92
  93 /* Enter a start condition.  This macro really ought to take a parameter,
  94  * but we do it the disgusting crufty way forced on us by the ()-less
  95  * definition of BEGIN.
  96  */
  97 #define BEGIN yy_start = 1 + 2 *
  98
  99 /* Translate the current start state into a value that can be later handed
 100  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 101  * compatibility.
 102  */
 103 #define YY_START ((yy_start - 1) / 2)
 104 #define YYSTATE YY_START
 105
 106 /* Action number for EOF rule of a given start state. */
 107 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 108
 109 /* Special action meaning "start processing a new file". */
 110 #define YY_NEW_FILE yyrestart( yyin )
 111
 112 #define YY_END_OF_BUFFER_CHAR 0
 113
 114 /* Size of default input buffer. */
 115 #define YY_BUF_SIZE 16384
 116
 117 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 118
 119 extern int yyleng;
 120 extern FILE *yyin, *yyout;
 121
 122 #define EOB_ACT_CONTINUE_SCAN 0
 123 #define EOB_ACT_END_OF_FILE 1
 124 #define EOB_ACT_LAST_MATCH 2
 125
 126 /* The funky do-while in the following #define is used to turn the definition
 127  * int a single C statement (which needs a semi-colon terminator).  This
 128  * avoids problems with code like:
 129  *
 130  *      if ( condition_holds )
 131  *              yyless( 5 );
 132  *      else
 133  *              do_something_else();
 134  *
 135  * Prior to using the do-while the compiler would get upset at the
 136  * "else" because it interpreted the "if" statement as being all
 137  * done when it reached the ';' after the yyless() call.
 138  */
 139
 140 /* Return all but the first 'n' matched characters back to the input stream. */
 141
 142 #define yyless(n) \
 143         do \
 144                 { \
 145                 /* Undo effects of setting up yytext. */ \
 146                 *yy_cp = yy_hold_char; \
 147                 YY_RESTORE_YY_MORE_OFFSET \
 148                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
 149                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 150                 } \
 151         while ( 0 )
 152
 153 #define unput(c) yyunput( c, yytext_ptr )
 154
 155 /* Some routines like yy_flex_realloc() are emitted as static but are
 156    not called by all lexers. This generates warnings in some compilers,
 157    notably GCC. Arrange to suppress these. */
 158 #ifdef __GNUC__
 159 #define YY_MAY_BE_UNUSED __attribute__((unused))
 160 #else
 161 #define YY_MAY_BE_UNUSED
 162 #endif
 163
 164 /* The following is because we cannot portably get our hands on size_t
 165  * (without autoconf's help, which isn't available because we want
 166  * flex-generated scanners to compile on their own).
 167  */
 168 typedef unsigned int yy_size_t;
 169
 170
 171 struct yy_buffer_state
 172         {
 173         FILE *yy_input_file;
 174
 175         char *yy_ch_buf;                /* input buffer */
 176         char *yy_buf_pos;               /* current position in input buffer */
 177
 178         /* Size of input buffer in bytes, not including room for EOB
 179          * characters.
 180          */
 181         yy_size_t yy_buf_size;
 182
 183         /* Number of characters read into yy_ch_buf, not including EOB
 184          * characters.
 185          */
 186         int yy_n_chars;
 187
 188         /* Whether we "own" the buffer - i.e., we know we created it,
 189          * and can realloc() it to grow it, and should free() it to
 190          * delete it.
 191          */
 192         int yy_is_our_buffer;
 193
 194         /* Whether this is an "interactive" input source; if so, and
 195          * if we're using stdio for input, then we want to use getc()
 196          * instead of fread(), to make sure we stop fetching input after
 197          * each newline.
 198          */
 199         int yy_is_interactive;
 200
 201         /* Whether we're considered to be at the beginning of a line.
 202          * If so, '^' rules will be active on the next match, otherwise
 203          * not.
 204          */
 205         int yy_at_bol;
 206
 207         /* Whether to try to fill the input buffer when we reach the
 208          * end of it.
 209          */
 210         int yy_fill_buffer;
 211
 212         int yy_buffer_status;
 213 #define YY_BUFFER_NEW 0
 214 #define YY_BUFFER_NORMAL 1
 215         /* When an EOF's been seen but there's still some text to process
 216          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 217          * shouldn't try reading from the input source any more.  We might
 218          * still have a bunch of tokens to match, though, because of
 219          * possible backing-up.
 220          *
 221          * When we actually see the EOF, we change the status to "new"
 222          * (via yyrestart()), so that the user can continue scanning by
 223          * just pointing yyin at a new input file.
 224          */
 225 #define YY_BUFFER_EOF_PENDING 2
 226         };
 227
 228 static YY_BUFFER_STATE yy_current_buffer = 0;
 229
 230 /* We provide macros for accessing buffer states in case in the
 231  * future we want to put the buffer states in a more general
 232  * "scanner state".
 233  */
 234 #define YY_CURRENT_BUFFER yy_current_buffer
 235
 236
 237 /* yy_hold_char holds the character lost when yytext is formed. */
 238 static char yy_hold_char;
 239
 240 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 241
 242
 243 int yyleng;
 244
 245 /* Points to current character in buffer. */
 246 static char *yy_c_buf_p = (char *) 0;
 247 static int yy_init = 1;         /* whether we need to initialize */
 248 static int yy_start = 0;        /* start state number */
 249
 250 /* Flag which is used to allow yywrap()'s to do buffer switches
 251  * instead of setting up a fresh yyin.  A bit of a hack ...
 252  */
 253 static int yy_did_buffer_switch_on_eof;
 254
 255 void yyrestart YY_PROTO(( FILE *input_file ));
 256
 257 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 258 void yy_load_buffer_state YY_PROTO(( void ));
 259 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
 260 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 261 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
 262 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 263 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 264
 265 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
 266 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
 267 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 268
 269 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
 270 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) YY_MAY_BE_UNUSED;
 271 static void yy_flex_free YY_PROTO(( void * ));
 272
 273 #define yy_new_buffer yy_create_buffer
 274
 275 #define yy_set_interactive(is_interactive) \
 276         { \
 277         if ( ! yy_current_buffer ) \
 278                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 279         yy_current_buffer->yy_is_interactive = is_interactive; \
 280         }
 281
 282 #define yy_set_bol(at_bol) \
 283         { \
 284         if ( ! yy_current_buffer ) \
 285                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 286         yy_current_buffer->yy_at_bol = at_bol; \
 287         }
 288
 289 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 290
 291
 292 #define yywrap() 1
 293 #define YY_SKIP_YYWRAP
 294 typedef unsigned char YY_CHAR;
 295 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 296 typedef int yy_state_type;
 297 extern char *yytext;
 298 #define yytext_ptr yytext
 299
 300 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 301 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 302 static int yy_get_next_buffer YY_PROTO(( void ));
 303 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 304
 305 /* Done after the current pattern has been matched and before the
 306  * corresponding action - sets up yytext.
 307  */
 308 #define YY_DO_BEFORE_ACTION \
 309         yytext_ptr = yy_bp; \
 310         yytext_ptr -= yy_more_len; \
 311         yyleng = (int) (yy_cp - yytext_ptr); \
 312         yy_hold_char = *yy_cp; \
 313         *yy_cp = '\0'; \
 314         yy_c_buf_p = yy_cp;
 315
 316 #define YY_NUM_RULES 11
 317 #define YY_END_OF_BUFFER 12
 318 static yyconst short int yy_accept[32] =
 319     {   0,
 320         0,    0,   12,   10,    6,    5,   10,   10,    1,    1,
 321         1,    2,    6,    5,    0,    4,    3,    0,    0,    0,
 322         2,    0,    7,    0,    8,    0,    0,    0,    0,    9,
 323         0
 324     } ;
 325
 326 static yyconst int yy_ec[256] =
 327     {   0,
 328         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 329         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
 330         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 331         1,    2,    1,    1,    1,    1,    1,    1,    4,    1,
 332         1,    1,    1,    1,    5,    1,    6,    7,    7,    7,
 333         7,    7,    7,    7,    7,    7,    7,    7,    1,    8,
 334         9,    9,   10,    1,   11,   11,   11,   11,   11,   11,
 335        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
 336        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
 337         1,    1,    1,    1,   11,    1,   11,   11,   11,   11,
 338
 339        11,   11,   11,   11,   11,   11,   11,   12,   13,   11,
 340        11,   11,   11,   11,   11,   11,   11,   11,   11,   14,
 341        11,   11,    1,    1,    1,    1,    1,    1,    1,    1,
 342         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 343         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 344         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 345         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 346         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 347         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 348         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 349
 350         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 351         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 352         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 353         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 354         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 355         1,    1,    1,    1,    1
 356     } ;
 357
 358 static yyconst int yy_meta[15] =
 359     {   0,
 360         1,    1,    2,    1,    3,    1,    3,    1,    1,    1,
 361         3,    3,    3,    3
 362     } ;
 363
 364 static yyconst short int yy_base[38] =
 365     {   0,
 366         0,    0,   48,   49,   45,    0,   12,   41,   39,   34,
 367        49,    0,   41,    0,   14,   49,   49,   39,   38,   26,
 368         0,   36,   49,   35,   49,   24,   24,   32,   31,   49,
 369        49,   18,   21,   17,   24,   27,   30
 370     } ;
 371
 372 static yyconst short int yy_def[38] =
 373     {   0,
 374        31,    1,   31,   31,   31,   32,   33,   31,   31,   31,
 375        31,   34,   31,   32,   33,   31,   31,   35,   36,   31,
 376        34,   35,   31,   36,   31,   31,   31,   37,   37,   31,
 377         0,   31,   31,   31,   31,   31,   31
 378     } ;
 379
 380 static yyconst short int yy_nxt[64] =
 381     {   0,
 382         4,    5,    6,    7,    8,    9,    4,   10,   11,    4,
 383        12,   12,   12,   12,   16,   17,   16,   17,   14,   21,
 384        14,   15,   15,   15,   22,   22,   22,   24,   24,   24,
 385        29,   29,   29,   30,   30,   28,   27,   25,   23,   26,
 386        25,   23,   13,   20,   19,   18,   13,   31,    3,   31,
 387        31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
 388        31,   31,   31
 389     } ;
 390
 391 static yyconst short int yy_chk[64] =
 392     {   0,
 393         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 394         1,    1,    1,    1,    7,    7,   15,   15,   32,   34,
 395        32,   33,   33,   33,   35,   35,   35,   36,   36,   36,
 396        37,   37,   37,   29,   28,   27,   26,   24,   22,   20,
 397        19,   18,   13,   10,    9,    8,    5,    3,   31,   31,
 398        31,   31,   31,   31,   31,   31,   31,   31,   31,   31,
 399        31,   31,   31
 400     } ;
 401
 402 static yy_state_type yy_last_accepting_state;
 403 static char *yy_last_accepting_cpos;
 404
 405 /* The intent behind this definition is that it'll catch
 406  * any uses of REJECT which flex missed.
 407  */
 408 #define REJECT reject_used_but_not_detected
 409 static int yy_more_flag = 0;
 410 static int yy_more_len = 0;
 411 #define yymore() (yy_more_flag = 1)
 412 #define YY_MORE_ADJ yy_more_len
 413 #define YY_RESTORE_YY_MORE_OFFSET
 414 char *yytext;
 415 #line 1 "xml.l"
 416 #define INITIAL 0
 417 /*
 418         MUST COMPILE WITH
 419                 flex -PxmlParser -oxmllexer.cc xml.l
 420         (or equivalent).
 421 */
 422 #line 9 "xml.l"
 423 /*
 424  * AT&T lex can't handle this lexer due to lex bugs.  It works with flex
 425  * 2.3.7, pclex 2.0.5, and MKS lex 3.1a.
 426  */
 427
 428  // #include "parse_fta.h"
 429  #include <string.h>
 430
 431
 432
 433 #include "xml.tab.hh"
 434
 435 /*
 436         Some includes that flex doesn't include as standard,
 437         but which are needed.
 438 */
 439
 440 #include <stdlib.h>
 441 #include <string.h>
 442
 443
 444 //              Prevent flex from defining yywrap as extern "C"
 445
 446 #define YY_SKIP_YYWRAP
 447
 448 /*              No lex lib, supply the yywrap fcn. that normally resides there
 449 */
 450
 451 int xmlParserwrap(){return(1);}
 452
 453 extern int xmlParserdebug;
 454
 455
 456 /*
 457                 These variables are used for error reporting:
 458                 flex_xml_lineno : the line currently being parsed when the error occurs.
 459                 flex_xml_ch : the character on the line where the error occurs
 460                 flex_xml_linebuf : store the line for reporting.
 461
 462                 NOTE : 1) the fixed size flex_xml_linebuf buffer is dangerous.
 463                            2) You might get pointed to a place shortly after
 464                                   where the syntax error occurs.  It is close enough
 465                                   for now.
 466 */
 467
 468 int flex_xml_lineno = 1;
 469 int flex_xml_ch = 0;
 470 char flex_xml_linebuf[20000];
 471
 472 char *flex_xml_stringinput = NULL;
 473 int flex_xml_stringinput_ptr = 0;
 474 FILE *flex_xml_fileinput = NULL;
 475 int my_xmlParser_yyinput(char *buf, int max_size);
 476
 477
 478
 479 void xmlParsererror(char *s){
 480         int i;
 481         fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n",
 482                                 flex_xml_lineno, flex_xml_ch, s, xmlParsertext, flex_xml_linebuf );
 483     for(i=0;i<flex_xml_ch;i++){
 484                 if(flex_xml_linebuf[i] == '\t'){
 485                         fprintf(stderr,"\t");
 486                 }else{
 487                         fprintf(stderr," ");
 488                 }
 489         }
 490         fprintf(stderr,"^\n");
 491         //      fprintf(stderr,"%*s\n",1+flex_xml_ch,"^");
 492 }
 493
 494 #undef YY_INPUT
 495 #define YY_INPUT(b, r, ms) (r = my_xmlParser_yyinput(b,ms))
 496
 497 /* MKS needs the next line to increase the NFA table */
 498 #line 499 "xmllexer.cc"
 499
 500 /* Macros after this point can all be overridden by user definitions in
 501  * section 1.
 502  */
 503
 504 #ifndef YY_SKIP_YYWRAP
 505 #ifdef __cplusplus
 506 extern "C" int yywrap YY_PROTO(( void ));
 507 #else
 508 extern int yywrap YY_PROTO(( void ));
 509 #endif
 510 #endif
 511
 512 #ifndef YY_NO_UNPUT
 513 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 514 #endif
 515
 516 #ifndef yytext_ptr
 517 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 518 #endif
 519
 520 #ifdef YY_NEED_STRLEN
 521 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 522 #endif
 523
 524 #ifndef YY_NO_INPUT
 525 #ifdef __cplusplus
 526 static int yyinput YY_PROTO(( void ));
 527 #else
 528 static int input YY_PROTO(( void ));
 529 #endif
 530 #endif
 531
 532 #if YY_STACK_USED
 533 static int yy_start_stack_ptr = 0;
 534 static int yy_start_stack_depth = 0;
 535 static int *yy_start_stack = 0;
 536 #ifndef YY_NO_PUSH_STATE
 537 static void yy_push_state YY_PROTO(( int new_state ));
 538 #endif
 539 #ifndef YY_NO_POP_STATE
 540 static void yy_pop_state YY_PROTO(( void ));
 541 #endif
 542 #ifndef YY_NO_TOP_STATE
 543 static int yy_top_state YY_PROTO(( void ));
 544 #endif
 545
 546 #else
 547 #define YY_NO_PUSH_STATE 1
 548 #define YY_NO_POP_STATE 1
 549 #define YY_NO_TOP_STATE 1
 550 #endif
 551
 552 #ifdef YY_MALLOC_DECL
 553 YY_MALLOC_DECL
 554 #else
 555 #if __STDC__
 556 #ifndef __cplusplus
 557 #include <stdlib.h>
 558 #endif
 559 #else
 560 /* Just try to get by without declaring the routines.  This will fail
 561  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 562  * or sizeof(void*) != sizeof(int).
 563  */
 564 #endif
 565 #endif
 566
 567 /* Amount of stuff to slurp up with each read. */
 568 #ifndef YY_READ_BUF_SIZE
 569 #define YY_READ_BUF_SIZE 8192
 570 #endif
 571
 572 /* Copy whatever the last rule matched to the standard output. */
 573
 574 #ifndef ECHO
 575 /* This used to be an fputs(), but since the string might contain NUL's,
 576  * we now use fwrite().
 577  */
 578 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 579 #endif
 580
 581 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 582  * is returned in "result".
 583  */
 584 #ifndef YY_INPUT
 585 #define YY_INPUT(buf,result,max_size) \
 586         if ( yy_current_buffer->yy_is_interactive ) \
 587                 { \
 588                 int c = '*', n; \
 589                 for ( n = 0; n < max_size && \
 590                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 591                         buf[n] = (char) c; \
 592                 if ( c == '\n' ) \
 593                         buf[n++] = (char) c; \
 594                 if ( c == EOF && ferror( yyin ) ) \
 595                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 596                 result = n; \
 597                 } \
 598         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
 599                   && ferror( yyin ) ) \
 600                 YY_FATAL_ERROR( "input in flex scanner failed" );
 601 #endif
 602
 603 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 604  * we don't want an extra ';' after the "return" because that will cause
 605  * some compilers to complain about unreachable statements.
 606  */
 607 #ifndef yyterminate
 608 #define yyterminate() return YY_NULL
 609 #endif
 610
 611 /* Number of entries by which start-condition stack grows. */
 612 #ifndef YY_START_STACK_INCR
 613 #define YY_START_STACK_INCR 25
 614 #endif
 615
 616 /* Report a fatal error. */
 617 #ifndef YY_FATAL_ERROR
 618 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 619 #endif
 620
 621 /* Default declaration of generated scanner - a define so the user can
 622  * easily add parameters.
 623  */
 624 #ifndef YY_DECL
 625 #define YY_DECL int yylex YY_PROTO(( void ))
 626 #endif
 627
 628 /* Code executed at the beginning of each rule, after yytext and yyleng
 629  * have been set up.
 630  */
 631 #ifndef YY_USER_ACTION
 632 #define YY_USER_ACTION
 633 #endif
 634
 635 /* Code executed at the end of each rule. */
 636 #ifndef YY_BREAK
 637 #define YY_BREAK break;
 638 #endif
 639
 640 #define YY_RULE_SETUP \
 641         YY_USER_ACTION
 642
 643 YY_DECL
 644         {
 645         register yy_state_type yy_current_state;
 646         register char *yy_cp = NULL, *yy_bp = NULL;
 647         register int yy_act;
 648
 649 #line 88 "xml.l"
 650
 651
 652         /* literal keyword tokens */
 653
 654  /*
 655                         The actions associated with each text token are to
 656                         keep track of the current location (for syntax error reporting)
 657                         and to report any necessary info to the emf.y parse tree builder
 658
 659                         Its likely that there are a number of omissions, inconsistencies
 660                         (some keywords do not need to be in caps), and relics
 661                         (keywords such as BETWEEN, INDICATOR, etc., are not used
 662                          in emf.y)
 663                         This parser is somewhat of a work in progress.
 664  */
 665
 666  /*             Query keywords          */
 667
 668
 669
 670
 671 #line 672 "xmllexer.cc"
 672
 673         if ( yy_init )
 674                 {
 675                 yy_init = 0;
 676
 677 #ifdef YY_USER_INIT
 678                 YY_USER_INIT;
 679 #endif
 680
 681                 if ( ! yy_start )
 682                         yy_start = 1;   /* first start state */
 683
 684                 if ( ! yyin )
 685                         yyin = stdin;
 686
 687                 if ( ! yyout )
 688                         yyout = stdout;
 689
 690                 if ( ! yy_current_buffer )
 691                         yy_current_buffer =
 692                                 yy_create_buffer( yyin, YY_BUF_SIZE );
 693
 694                 yy_load_buffer_state();
 695                 }
 696
 697         while ( 1 )             /* loops until end-of-file is reached */
 698                 {
 699                 yy_more_len = 0;
 700                 if ( yy_more_flag )
 701                         {
 702                         yy_more_len = yy_c_buf_p - yytext_ptr;
 703                         yy_more_flag = 0;
 704                         }
 705                 yy_cp = yy_c_buf_p;
 706
 707                 /* Support of yytext. */
 708                 *yy_cp = yy_hold_char;
 709
 710                 /* yy_bp points to the position in yy_ch_buf of the start of
 711                  * the current run.
 712                  */
 713                 yy_bp = yy_cp;
 714
 715                 yy_current_state = yy_start;
 716 yy_match:
 717                 do
 718                         {
 719                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 720                         if ( yy_accept[yy_current_state] )
 721                                 {
 722                                 yy_last_accepting_state = yy_current_state;
 723                                 yy_last_accepting_cpos = yy_cp;
 724                                 }
 725                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 726                                 {
 727                                 yy_current_state = (int) yy_def[yy_current_state];
 728                                 if ( yy_current_state >= 32 )
 729                                         yy_c = yy_meta[(unsigned int) yy_c];
 730                                 }
 731                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 732                         ++yy_cp;
 733                         }
 734                 while ( yy_base[yy_current_state] != 49 );
 735
 736 yy_find_action:
 737                 yy_act = yy_accept[yy_current_state];
 738                 if ( yy_act == 0 )
 739                         { /* have to back up */
 740                         yy_cp = yy_last_accepting_cpos;
 741                         yy_current_state = yy_last_accepting_state;
 742                         yy_act = yy_accept[yy_current_state];
 743                         }
 744
 745                 YY_DO_BEFORE_ACTION;
 746
 747
 748 do_action:      /* This label is used only to access EOF actions. */
 749
 750
 751                 switch ( yy_act )
 752         { /* beginning of action switch */
 753                         case 0: /* must back up */
 754                         /* undo the effects of YY_DO_BEFORE_ACTION */
 755                         *yy_cp = yy_hold_char;
 756                         yy_cp = yy_last_accepting_cpos;
 757                         yy_current_state = yy_last_accepting_state;
 758                         goto yy_find_action;
 759
 760 case 1:
 761 YY_RULE_SETUP
 762 #line 109 "xml.l"
 763 { flex_xml_ch+=xmlParserleng; return yytext[0]; }
 764         YY_BREAK
 765 /* names */
 766 case 2:
 767 YY_RULE_SETUP
 768 #line 113 "xml.l"
 769 { flex_xml_ch+=xmlParserleng; xmlParserlval.strval = strdup(yytext); return NAME; }
 770         YY_BREAK
 771 /* strings */
 772 case 3:
 773 YY_RULE_SETUP
 774 #line 118 "xml.l"
 775 {
 776
 777                 int c;
 778
 779                 xmlParserlval.strval = strdup(xmlParsertext+1);
 780
 781                 c = yyinput();
 782
 783                 unput(c);       /* just peeking */
 784                 if(c != '\'') {
 785                         flex_xml_ch+=xmlParserleng;
 786                         xmlParserlval.strval[xmlParserleng-2] = '\0';
 787                         return STRING_TOKEN;
 788                 } else
 789                         yymore();
 790         }
 791         YY_BREAK
 792 case 4:
 793 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
 794 yy_c_buf_p = yy_cp -= 1;
 795 YY_DO_BEFORE_ACTION; /* set up yytext again */
 796 YY_RULE_SETUP
 797 #line 135 "xml.l"
 798 { flex_xml_ch+=xmlParserleng; xmlParsererror("Unterminated string"); }
 799         YY_BREAK
 800 /*                                                                                                                      */
 801 /*              Newline : advance the error reporting line number       */
 802 /*              and grab the next line into flex_xml_linebuf                    */
 803 /*                                                                                                                      */
 804 case 5:
 805 YY_RULE_SETUP
 806 #line 142 "xml.l"
 807 {flex_xml_ch=0; flex_xml_lineno++;
 808                            strcpy(flex_xml_linebuf,xmlParsertext+1);
 809                            yyless(1);
 810                            }
 811         YY_BREAK
 812 case 6:
 813 YY_RULE_SETUP
 814 #line 147 "xml.l"
 815 {flex_xml_ch+=xmlParserleng; }  /* white space */
 816         YY_BREAK
 817 case 7:
 818 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
 819 yy_c_buf_p = yy_cp -= 1;
 820 YY_DO_BEFORE_ACTION; /* set up yytext again */
 821 YY_RULE_SETUP
 822 #line 149 "xml.l"
 823 {flex_xml_ch+=xmlParserleng; }; /* comment */
 824         YY_BREAK
 825 case 8:
 826 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
 827 yy_c_buf_p = yy_cp -= 1;
 828 YY_DO_BEFORE_ACTION; /* set up yytext again */
 829 YY_RULE_SETUP
 830 #line 150 "xml.l"
 831 {flex_xml_ch+=xmlParserleng; }; /* comment */
 832         YY_BREAK
 833 case 9:
 834 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
 835 yy_c_buf_p = yy_cp -= 1;
 836 YY_DO_BEFORE_ACTION; /* set up yytext again */
 837 YY_RULE_SETUP
 838 #line 151 "xml.l"
 839 {flex_xml_ch+=xmlParserleng; }; /* comment */
 840         YY_BREAK
 841 case 10:
 842 YY_RULE_SETUP
 843 #line 153 "xml.l"
 844 {flex_xml_ch+=xmlParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n");  xmlParsererror(yytext);}
 845         YY_BREAK
 846 case 11:
 847 YY_RULE_SETUP
 848 #line 155 "xml.l"
 849 ECHO;
 850         YY_BREAK
 851 #line 852 "xmllexer.cc"
 852 case YY_STATE_EOF(INITIAL):
 853         yyterminate();
 854
 855         case YY_END_OF_BUFFER:
 856                 {
 857                 /* Amount of text matched not including the EOB char. */
 858                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
 859
 860                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 861                 *yy_cp = yy_hold_char;
 862                 YY_RESTORE_YY_MORE_OFFSET
 863
 864                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
 865                         {
 866                         /* We're scanning a new file or input source.  It's
 867                          * possible that this happened because the user
 868                          * just pointed yyin at a new source and called
 869                          * yylex().  If so, then we have to assure
 870                          * consistency between yy_current_buffer and our
 871                          * globals.  Here is the right place to do so, because
 872                          * this is the first action (other than possibly a
 873                          * back-up) that will match for the new input source.
 874                          */
 875                         yy_n_chars = yy_current_buffer->yy_n_chars;
 876                         yy_current_buffer->yy_input_file = yyin;
 877                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
 878                         }
 879
 880                 /* Note that here we test for yy_c_buf_p "<=" to the position
 881                  * of the first EOB in the buffer, since yy_c_buf_p will
 882                  * already have been incremented past the NUL character
 883                  * (since all states make transitions on EOB to the
 884                  * end-of-buffer state).  Contrast this with the test
 885                  * in input().
 886                  */
 887                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
 888                         { /* This was really a NUL. */
 889                         yy_state_type yy_next_state;
 890
 891                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
 892
 893                         yy_current_state = yy_get_previous_state();
 894
 895                         /* Okay, we're now positioned to make the NUL
 896                          * transition.  We couldn't have
 897                          * yy_get_previous_state() go ahead and do it
 898                          * for us because it doesn't know how to deal
 899                          * with the possibility of jamming (and we don't
 900                          * want to build jamming into it because then it
 901                          * will run more slowly).
 902                          */
 903
 904                         yy_next_state = yy_try_NUL_trans( yy_current_state );
 905
 906                         yy_bp = yytext_ptr + YY_MORE_ADJ;
 907
 908                         if ( yy_next_state )
 909                                 {
 910                                 /* Consume the NUL. */
 911                                 yy_cp = ++yy_c_buf_p;
 912                                 yy_current_state = yy_next_state;
 913                                 goto yy_match;
 914                                 }
 915
 916                         else
 917                                 {
 918                                 yy_cp = yy_c_buf_p;
 919                                 goto yy_find_action;
 920                                 }
 921                         }
 922
 923                 else switch ( yy_get_next_buffer() )
 924                         {
 925                         case EOB_ACT_END_OF_FILE:
 926                                 {
 927                                 yy_did_buffer_switch_on_eof = 0;
 928
 929                                 if ( yywrap() )
 930                                         {
 931                                         /* Note: because we've taken care in
 932                                          * yy_get_next_buffer() to have set up
 933                                          * yytext, we can now set up
 934                                          * yy_c_buf_p so that if some total
 935                                          * hoser (like flex itself) wants to
 936                                          * call the scanner after we return the
 937                                          * YY_NULL, it'll still work - another
 938                                          * YY_NULL will get returned.
 939                                          */
 940                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
 941
 942                                         yy_act = YY_STATE_EOF(YY_START);
 943                                         goto do_action;
 944                                         }
 945
 946                                 else
 947                                         {
 948                                         if ( ! yy_did_buffer_switch_on_eof )
 949                                                 YY_NEW_FILE;
 950                                         }
 951                                 break;
 952                                 }
 953
 954                         case EOB_ACT_CONTINUE_SCAN:
 955                                 yy_c_buf_p =
 956                                         yytext_ptr + yy_amount_of_matched_text;
 957
 958                                 yy_current_state = yy_get_previous_state();
 959
 960                                 yy_cp = yy_c_buf_p;
 961                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
 962                                 goto yy_match;
 963
 964                         case EOB_ACT_LAST_MATCH:
 965                                 yy_c_buf_p =
 966                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
 967
 968                                 yy_current_state = yy_get_previous_state();
 969
 970                                 yy_cp = yy_c_buf_p;
 971                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
 972                                 goto yy_find_action;
 973                         }
 974                 break;
 975                 }
 976
 977         default:
 978                 YY_FATAL_ERROR(
 979                         "fatal flex scanner internal error--no action found" );
 980         } /* end of action switch */
 981                 } /* end of scanning one token */
 982         } /* end of yylex */
 983
 984
 985 /* yy_get_next_buffer - try to read in a new buffer
 986  *
 987  * Returns a code representing an action:
 988  *      EOB_ACT_LAST_MATCH -
 989  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 990  *      EOB_ACT_END_OF_FILE - end of file
 991  */
 992
 993 static int yy_get_next_buffer()
 994         {
 995         register char *dest = yy_current_buffer->yy_ch_buf;
 996         register char *source = yytext_ptr;
 997         register int number_to_move, i;
 998         int ret_val;
 999
1000         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1001                 YY_FATAL_ERROR(
1002                 "fatal flex scanner internal error--end of buffer missed" );
1003
1004         if ( yy_current_buffer->yy_fill_buffer == 0 )
1005                 { /* Don't try to fill the buffer, so this is an EOF. */
1006                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1007                         {
1008                         /* We matched a single character, the EOB, so
1009                          * treat this as a final EOF.
1010                          */
1011                         return EOB_ACT_END_OF_FILE;
1012                         }
1013
1014                 else
1015                         {
1016                         /* We matched some text prior to the EOB, first
1017                          * process it.
1018                          */
1019                         return EOB_ACT_LAST_MATCH;
1020                         }
1021                 }
1022
1023         /* Try to read more data. */
1024
1025         /* First move last chars to start of buffer. */
1026         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1027
1028         for ( i = 0; i < number_to_move; ++i )
1029                 *(dest++) = *(source++);
1030
1031         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1032                 /* don't do the read, it's not guaranteed to return an EOF,
1033                  * just force an EOF
1034                  */
1035                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1036
1037         else
1038                 {
1039                 int num_to_read =
1040                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1041
1042                 while ( num_to_read <= 0 )
1043                         { /* Not enough room in the buffer - grow it. */
1044 #ifdef YY_USES_REJECT
1045                         YY_FATAL_ERROR(
1046 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1047 #else
1048
1049                         /* just a shorter name for the current buffer */
1050                         YY_BUFFER_STATE b = yy_current_buffer;
1051
1052                         int yy_c_buf_p_offset =
1053                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1054
1055                         if ( b->yy_is_our_buffer )
1056                                 {
1057                                 int new_size = b->yy_buf_size * 2;
1058
1059                                 if ( new_size <= 0 )
1060                                         b->yy_buf_size += b->yy_buf_size / 8;
1061                                 else
1062                                         b->yy_buf_size *= 2;
1063
1064                                 b->yy_ch_buf = (char *)
1065                                         /* Include room in for 2 EOB chars. */
1066                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1067                                                          b->yy_buf_size + 2 );
1068                                 }
1069                         else
1070                                 /* Can't grow it, we don't own it. */
1071                                 b->yy_ch_buf = 0;
1072
1073                         if ( ! b->yy_ch_buf )
1074                                 YY_FATAL_ERROR(
1075                                 "fatal error - scanner input buffer overflow" );
1076
1077                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1078
1079                         num_to_read = yy_current_buffer->yy_buf_size -
1080                                                 number_to_move - 1;
1081 #endif
1082                         }
1083
1084                 if ( num_to_read > YY_READ_BUF_SIZE )
1085                         num_to_read = YY_READ_BUF_SIZE;
1086
1087                 /* Read in more data. */
1088                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1089                         yy_n_chars, num_to_read );
1090
1091                 yy_current_buffer->yy_n_chars = yy_n_chars;
1092                 }
1093
1094         if ( yy_n_chars == 0 )
1095                 {
1096                 if ( number_to_move == YY_MORE_ADJ )
1097                         {
1098                         ret_val = EOB_ACT_END_OF_FILE;
1099                         yyrestart( yyin );
1100                         }
1101
1102                 else
1103                         {
1104                         ret_val = EOB_ACT_LAST_MATCH;
1105                         yy_current_buffer->yy_buffer_status =
1106                                 YY_BUFFER_EOF_PENDING;
1107                         }
1108                 }
1109
1110         else
1111                 ret_val = EOB_ACT_CONTINUE_SCAN;
1112
1113         yy_n_chars += number_to_move;
1114         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1115         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1116
1117         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1118
1119         return ret_val;
1120         }
1121
1122
1123 /* yy_get_previous_state - get the state just before the EOB char was reached */
1124
1125 static yy_state_type yy_get_previous_state()
1126         {
1127         register yy_state_type yy_current_state;
1128         register char *yy_cp;
1129
1130         yy_current_state = yy_start;
1131
1132         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1133                 {
1134                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1135                 if ( yy_accept[yy_current_state] )
1136                         {
1137                         yy_last_accepting_state = yy_current_state;
1138                         yy_last_accepting_cpos = yy_cp;
1139                         }
1140                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1141                         {
1142                         yy_current_state = (int) yy_def[yy_current_state];
1143                         if ( yy_current_state >= 32 )
1144                                 yy_c = yy_meta[(unsigned int) yy_c];
1145                         }
1146                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1147                 }
1148
1149         return yy_current_state;
1150         }
1151
1152
1153 /* yy_try_NUL_trans - try to make a transition on the NUL character
1154  *
1155  * synopsis
1156  *      next_state = yy_try_NUL_trans( current_state );
1157  */
1158
1159 #ifdef YY_USE_PROTOS
1160 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1161 #else
1162 static yy_state_type yy_try_NUL_trans( yy_current_state )
1163 yy_state_type yy_current_state;
1164 #endif
1165         {
1166         register int yy_is_jam;
1167         register char *yy_cp = yy_c_buf_p;
1168
1169         register YY_CHAR yy_c = 1;
1170         if ( yy_accept[yy_current_state] )
1171                 {
1172                 yy_last_accepting_state = yy_current_state;
1173                 yy_last_accepting_cpos = yy_cp;
1174                 }
1175         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1176                 {
1177                 yy_current_state = (int) yy_def[yy_current_state];
1178                 if ( yy_current_state >= 32 )
1179                         yy_c = yy_meta[(unsigned int) yy_c];
1180                 }
1181         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1182         yy_is_jam = (yy_current_state == 31);
1183
1184         return yy_is_jam ? 0 : yy_current_state;
1185         }
1186
1187
1188 #ifndef YY_NO_UNPUT
1189 #ifdef YY_USE_PROTOS
1190 static void yyunput( int c, register char *yy_bp )
1191 #else
1192 static void yyunput( c, yy_bp )
1193 int c;
1194 register char *yy_bp;
1195 #endif
1196         {
1197         register char *yy_cp = yy_c_buf_p;
1198
1199         /* undo effects of setting up yytext */
1200         *yy_cp = yy_hold_char;
1201
1202         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1203                 { /* need to shift things up to make room */
1204                 /* +2 for EOB chars. */
1205                 register int number_to_move = yy_n_chars + 2;
1206                 register char *dest = &yy_current_buffer->yy_ch_buf[
1207                                         yy_current_buffer->yy_buf_size + 2];
1208                 register char *source =
1209                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1210
1211                 while ( source > yy_current_buffer->yy_ch_buf )
1212                         *--dest = *--source;
1213
1214                 yy_cp += (int) (dest - source);
1215                 yy_bp += (int) (dest - source);
1216                 yy_current_buffer->yy_n_chars =
1217                         yy_n_chars = yy_current_buffer->yy_buf_size;
1218
1219                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1220                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1221                 }
1222
1223         *--yy_cp = (char) c;
1224
1225
1226         yytext_ptr = yy_bp;
1227         yy_hold_char = *yy_cp;
1228         yy_c_buf_p = yy_cp;
1229         }
1230 #endif  /* ifndef YY_NO_UNPUT */
1231
1232
1233 #ifndef YY_NO_INPUT
1234 #ifdef __cplusplus
1235 static int yyinput()
1236 #else
1237 static int input()
1238 #endif
1239         {
1240         int c;
1241
1242         *yy_c_buf_p = yy_hold_char;
1243
1244         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1245                 {
1246                 /* yy_c_buf_p now points to the character we want to return.
1247                  * If this occurs *before* the EOB characters, then it's a
1248                  * valid NUL; if not, then we've hit the end of the buffer.
1249                  */
1250                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1251                         /* This was really a NUL. */
1252                         *yy_c_buf_p = '\0';
1253
1254                 else
1255                         { /* need more input */
1256                         int offset = yy_c_buf_p - yytext_ptr;
1257                         ++yy_c_buf_p;
1258
1259                         switch ( yy_get_next_buffer() )
1260                                 {
1261                                 case EOB_ACT_LAST_MATCH:
1262                                         /* This happens because yy_g_n_b()
1263                                          * sees that we've accumulated a
1264                                          * token and flags that we need to
1265                                          * try matching the token before
1266                                          * proceeding.  But for input(),
1267                                          * there's no matching to consider.
1268                                          * So convert the EOB_ACT_LAST_MATCH
1269                                          * to EOB_ACT_END_OF_FILE.
1270                                          */
1271
1272                                         /* Reset buffer status. */
1273                                         yyrestart( yyin );
1274
1275                                         /* fall through */
1276
1277                                 case EOB_ACT_END_OF_FILE:
1278                                         {
1279                                         if ( yywrap() )
1280                                                 return EOF;
1281
1282                                         if ( ! yy_did_buffer_switch_on_eof )
1283                                                 YY_NEW_FILE;
1284 #ifdef __cplusplus
1285                                         return yyinput();
1286 #else
1287                                         return input();
1288 #endif
1289                                         }
1290
1291                                 case EOB_ACT_CONTINUE_SCAN:
1292                                         yy_c_buf_p = yytext_ptr + offset;
1293                                         break;
1294                                 }
1295                         }
1296                 }
1297
1298         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1299         *yy_c_buf_p = '\0';     /* preserve yytext */
1300         yy_hold_char = *++yy_c_buf_p;
1301
1302
1303         return c;
1304         }
1305 #endif /* YY_NO_INPUT */
1306
1307 #ifdef YY_USE_PROTOS
1308 void yyrestart( FILE *input_file )
1309 #else
1310 void yyrestart( input_file )
1311 FILE *input_file;
1312 #endif
1313         {
1314         if ( ! yy_current_buffer )
1315                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1316
1317         yy_init_buffer( yy_current_buffer, input_file );
1318         yy_load_buffer_state();
1319         }
1320
1321
1322 #ifdef YY_USE_PROTOS
1323 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1324 #else
1325 void yy_switch_to_buffer( new_buffer )
1326 YY_BUFFER_STATE new_buffer;
1327 #endif
1328         {
1329         if ( yy_current_buffer == new_buffer )
1330                 return;
1331
1332         if ( yy_current_buffer )
1333                 {
1334                 /* Flush out information for old buffer. */
1335                 *yy_c_buf_p = yy_hold_char;
1336                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1337                 yy_current_buffer->yy_n_chars = yy_n_chars;
1338                 }
1339
1340         yy_current_buffer = new_buffer;
1341         yy_load_buffer_state();
1342
1343         /* We don't actually know whether we did this switch during
1344          * EOF (yywrap()) processing, but the only time this flag
1345          * is looked at is after yywrap() is called, so it's safe
1346          * to go ahead and always set it.
1347          */
1348         yy_did_buffer_switch_on_eof = 1;
1349         }
1350
1351
1352 #ifdef YY_USE_PROTOS
1353 void yy_load_buffer_state( void )
1354 #else
1355 void yy_load_buffer_state()
1356 #endif
1357         {
1358         yy_n_chars = yy_current_buffer->yy_n_chars;
1359         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1360         yyin = yy_current_buffer->yy_input_file;
1361         yy_hold_char = *yy_c_buf_p;
1362         }
1363
1364
1365 #ifdef YY_USE_PROTOS
1366 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1367 #else
1368 YY_BUFFER_STATE yy_create_buffer( file, size )
1369 FILE *file;
1370 int size;
1371 #endif
1372         {
1373         YY_BUFFER_STATE b;
1374
1375         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1376         if ( ! b )
1377                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1378
1379         b->yy_buf_size = size;
1380
1381         /* yy_ch_buf has to be 2 characters longer than the size given because
1382          * we need to put in 2 end-of-buffer characters.
1383          */
1384         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1385         if ( ! b->yy_ch_buf )
1386                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1387
1388         b->yy_is_our_buffer = 1;
1389
1390         yy_init_buffer( b, file );
1391
1392         return b;
1393         }
1394
1395
1396 #ifdef YY_USE_PROTOS
1397 void yy_delete_buffer( YY_BUFFER_STATE b )
1398 #else
1399 void yy_delete_buffer( b )
1400 YY_BUFFER_STATE b;
1401 #endif
1402         {
1403         if ( ! b )
1404                 return;
1405
1406         if ( b == yy_current_buffer )
1407                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1408
1409         if ( b->yy_is_our_buffer )
1410                 yy_flex_free( (void *) b->yy_ch_buf );
1411
1412         yy_flex_free( (void *) b );
1413         }
1414
1415
1416
1417 #ifdef YY_USE_PROTOS
1418 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1419 #else
1420 void yy_init_buffer( b, file )
1421 YY_BUFFER_STATE b;
1422 FILE *file;
1423 #endif
1424
1425
1426         {
1427         yy_flush_buffer( b );
1428
1429         b->yy_input_file = file;
1430         b->yy_fill_buffer = 1;
1431
1432 #if YY_ALWAYS_INTERACTIVE
1433         b->yy_is_interactive = 1;
1434 #else
1435 #if YY_NEVER_INTERACTIVE
1436         b->yy_is_interactive = 0;
1437 #else
1438         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1439 #endif
1440 #endif
1441         }
1442
1443
1444 #ifdef YY_USE_PROTOS
1445 void yy_flush_buffer( YY_BUFFER_STATE b )
1446 #else
1447 void yy_flush_buffer( b )
1448 YY_BUFFER_STATE b;
1449 #endif
1450
1451         {
1452         if ( ! b )
1453                 return;
1454
1455         b->yy_n_chars = 0;
1456
1457         /* We always need two end-of-buffer characters.  The first causes
1458          * a transition to the end-of-buffer state.  The second causes
1459          * a jam in that state.
1460          */
1461         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1462         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1463
1464         b->yy_buf_pos = &b->yy_ch_buf[0];
1465
1466         b->yy_at_bol = 1;
1467         b->yy_buffer_status = YY_BUFFER_NEW;
1468
1469         if ( b == yy_current_buffer )
1470                 yy_load_buffer_state();
1471         }
1472
1473
1474 #ifndef YY_NO_SCAN_BUFFER
1475 #ifdef YY_USE_PROTOS
1476 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1477 #else
1478 YY_BUFFER_STATE yy_scan_buffer( base, size )
1479 char *base;
1480 yy_size_t size;
1481 #endif
1482         {
1483         YY_BUFFER_STATE b;
1484
1485         if ( size < 2 ||
1486              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1487              base[size-1] != YY_END_OF_BUFFER_CHAR )
1488                 /* They forgot to leave room for the EOB's. */
1489                 return 0;
1490
1491         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1492         if ( ! b )
1493                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1494
1495         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1496         b->yy_buf_pos = b->yy_ch_buf = base;
1497         b->yy_is_our_buffer = 0;
1498         b->yy_input_file = 0;
1499         b->yy_n_chars = b->yy_buf_size;
1500         b->yy_is_interactive = 0;
1501         b->yy_at_bol = 1;
1502         b->yy_fill_buffer = 0;
1503         b->yy_buffer_status = YY_BUFFER_NEW;
1504
1505         yy_switch_to_buffer( b );
1506
1507         return b;
1508         }
1509 #endif
1510
1511
1512 #ifndef YY_NO_SCAN_STRING
1513 #ifdef YY_USE_PROTOS
1514 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1515 #else
1516 YY_BUFFER_STATE yy_scan_string( yy_str )
1517 yyconst char *yy_str;
1518 #endif
1519         {
1520         int len;
1521         for ( len = 0; yy_str[len]; ++len )
1522                 ;
1523
1524         return yy_scan_bytes( yy_str, len );
1525         }
1526 #endif
1527
1528
1529 #ifndef YY_NO_SCAN_BYTES
1530 #ifdef YY_USE_PROTOS
1531 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1532 #else
1533 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1534 yyconst char *bytes;
1535 int len;
1536 #endif
1537         {
1538         YY_BUFFER_STATE b;
1539         char *buf;
1540         yy_size_t n;
1541         int i;
1542
1543         /* Get memory for full buffer, including space for trailing EOB's. */
1544         n = len + 2;
1545         buf = (char *) yy_flex_alloc( n );
1546         if ( ! buf )
1547                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1548
1549         for ( i = 0; i < len; ++i )
1550                 buf[i] = bytes[i];
1551
1552         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1553
1554         b = yy_scan_buffer( buf, n );
1555         if ( ! b )
1556                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1557
1558         /* It's okay to grow etc. this buffer, and we should throw it
1559          * away when we're done.
1560          */
1561         b->yy_is_our_buffer = 1;
1562
1563         return b;
1564         }
1565 #endif
1566
1567
1568 #ifndef YY_NO_PUSH_STATE
1569 #ifdef YY_USE_PROTOS
1570 static void yy_push_state( int new_state )
1571 #else
1572 static void yy_push_state( new_state )
1573 int new_state;
1574 #endif
1575         {
1576         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1577                 {
1578                 yy_size_t new_size;
1579
1580                 yy_start_stack_depth += YY_START_STACK_INCR;
1581                 new_size = yy_start_stack_depth * sizeof( int );
1582
1583                 if ( ! yy_start_stack )
1584                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1585
1586                 else
1587                         yy_start_stack = (int *) yy_flex_realloc(
1588                                         (void *) yy_start_stack, new_size );
1589
1590                 if ( ! yy_start_stack )
1591                         YY_FATAL_ERROR(
1592                         "out of memory expanding start-condition stack" );
1593                 }
1594
1595         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1596
1597         BEGIN(new_state);
1598         }
1599 #endif
1600
1601
1602 #ifndef YY_NO_POP_STATE
1603 static void yy_pop_state()
1604         {
1605         if ( --yy_start_stack_ptr < 0 )
1606                 YY_FATAL_ERROR( "start-condition stack underflow" );
1607
1608         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1609         }
1610 #endif
1611
1612
1613 #ifndef YY_NO_TOP_STATE
1614 static int yy_top_state()
1615         {
1616         return yy_start_stack[yy_start_stack_ptr - 1];
1617         }
1618 #endif
1619
1620 #ifndef YY_EXIT_FAILURE
1621 #define YY_EXIT_FAILURE 2
1622 #endif
1623
1624 #ifdef YY_USE_PROTOS
1625 static void yy_fatal_error( yyconst char msg[] )
1626 #else
1627 static void yy_fatal_error( msg )
1628 char msg[];
1629 #endif
1630         {
1631         (void) fprintf( stderr, "%s\n", msg );
1632         exit( YY_EXIT_FAILURE );
1633         }
1634
1635
1636
1637 /* Redefine yyless() so it works in section 3 code. */
1638
1639 #undef yyless
1640 #define yyless(n) \
1641         do \
1642                 { \
1643                 /* Undo effects of setting up yytext. */ \
1644                 yytext[yyleng] = yy_hold_char; \
1645                 yy_c_buf_p = yytext + n; \
1646                 yy_hold_char = *yy_c_buf_p; \
1647                 *yy_c_buf_p = '\0'; \
1648                 yyleng = n; \
1649                 } \
1650         while ( 0 )
1651
1652
1653 /* Internal utility routines. */
1654
1655 #ifndef yytext_ptr
1656 #ifdef YY_USE_PROTOS
1657 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1658 #else
1659 static void yy_flex_strncpy( s1, s2, n )
1660 char *s1;
1661 yyconst char *s2;
1662 int n;
1663 #endif
1664         {
1665         register int i;
1666         for ( i = 0; i < n; ++i )
1667                 s1[i] = s2[i];
1668         }
1669 #endif
1670
1671 #ifdef YY_NEED_STRLEN
1672 #ifdef YY_USE_PROTOS
1673 static int yy_flex_strlen( yyconst char *s )
1674 #else
1675 static int yy_flex_strlen( s )
1676 yyconst char *s;
1677 #endif
1678         {
1679         register int n;
1680         for ( n = 0; s[n]; ++n )
1681                 ;
1682
1683         return n;
1684         }
1685 #endif
1686
1687
1688 #ifdef YY_USE_PROTOS
1689 static void *yy_flex_alloc( yy_size_t size )
1690 #else
1691 static void *yy_flex_alloc( size )
1692 yy_size_t size;
1693 #endif
1694         {
1695         return (void *) malloc( size );
1696         }
1697
1698 #ifdef YY_USE_PROTOS
1699 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1700 #else
1701 static void *yy_flex_realloc( ptr, size )
1702 void *ptr;
1703 yy_size_t size;
1704 #endif
1705         {
1706         /* The cast to (char *) in the following accommodates both
1707          * implementations that use char* generic pointers, and those
1708          * that use void* generic pointers.  It works with the latter
1709          * because both ANSI C and C++ allow castless assignment from
1710          * any pointer type to void*, and deal with argument conversions
1711          * as though doing an assignment.
1712          */
1713         return (void *) realloc( (char *) ptr, size );
1714         }
1715
1716 #ifdef YY_USE_PROTOS
1717 static void yy_flex_free( void *ptr )
1718 #else
1719 static void yy_flex_free( ptr )
1720 void *ptr;
1721 #endif
1722         {
1723         free( ptr );
1724         }
1725
1726 #if YY_MAIN
1727 int main()
1728         {
1729         yylex();
1730         return 0;
1731         }
1732 #endif
1733 #line 155 "xml.l"
1734
1735
1736 int my_xmlParser_yyinput(char *buf, int max_size){
1737         int c = 0;
1738         int inchar = 0;
1739
1740         if(flex_xml_stringinput != NULL){
1741                 while(c<max_size){
1742                         if(flex_xml_stringinput[flex_xml_stringinput_ptr] != '\0'){
1743                                 buf[c++] = flex_xml_stringinput[flex_xml_stringinput_ptr++];
1744                         }else{
1745                                 break;
1746                         }
1747                 }
1748                 return(c);
1749         }
1750
1751         if(flex_xml_fileinput != NULL){
1752                 while(c < max_size){
1753                         inchar = getc(flex_xml_fileinput);
1754                         if(inchar != EOF){
1755                                 buf[c++] = inchar;
1756                         }else{
1757                                 break;
1758                         }
1759                 }
1760                 return(c);
1761         }
1762
1763         return(0);
1764 }
1765
1766 void xmlParser_setfileinput(FILE *f){
1767         xmlParserrestart(NULL);
1768
1769         flex_xml_fileinput = f;
1770         flex_xml_stringinput = NULL;
1771         flex_xml_lineno = 1;
1772         flex_xml_ch = 0;
1773 }
1774
1775 void xmlParser_setstringinput(char *s){
1776         xmlParserrestart(NULL);
1777
1778         flex_xml_fileinput = NULL;
1779         flex_xml_stringinput = s;
1780         flex_xml_stringinput_ptr = 0;
1781         flex_xml_lineno = 1;
1782         flex_xml_ch = 0;
1783 }
1784
1785
1786
1787
1788