Logo AND Algorithmique Numérique Distribuée

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