src/gras/DataDesc/ddt_parse.yy.c

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