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