FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
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>
65typedef int8_t flex_int8_t;
66typedef uint8_t flex_uint8_t;
67typedef int16_t flex_int16_t;
68typedef uint16_t flex_uint16_t;
69typedef int32_t flex_int32_t;
70typedef uint32_t flex_uint32_t;
71#else
72typedef signed char flex_int8_t;
73typedef short int flex_int16_t;
74typedef int flex_int32_t;
75typedef unsigned char flex_uint8_t;
76typedef unsigned short int flex_uint16_t;
77typedef 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
177typedef size_t yy_size_t;
178#endif
179
180extern int yyleng;
181
182extern 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
207struct 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 */
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 */
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
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. */
269static size_t yy_buffer_stack_top = 0;
270static size_t yy_buffer_stack_max = 0;
271static 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. */
288static char yy_hold_char;
289static int yy_n_chars; /* number of characters read into yy_ch_buf */
291
292/* Points to current character in buffer. */
293static char *yy_c_buf_p = NULL;
294static int yy_init = 0; /* whether we need to initialize */
295static 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 */
300static int yy_did_buffer_switch_on_eof;
301
302void yyrestart(FILE *input_file);
304YY_BUFFER_STATE yy_create_buffer(FILE *file, int size);
309
310static void yyensure_buffer_stack(void);
311static void yy_load_buffer_state(void);
312static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file);
313
314#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER)
315
319
321void *yyrealloc(void *, yy_size_t);
322void 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
348typedef unsigned char YY_CHAR;
349
350FILE *yyin = NULL, *yyout = NULL;
351
352typedef int yy_state_type;
353
354extern int yylineno;
355
356int yylineno = 1;
357
358extern char *yytext;
359#ifdef yytext_ptr
360#undef yytext_ptr
361#endif
362#define yytext_ptr yytext
363
364static yy_state_type yy_get_previous_state(void);
365static yy_state_type yy_try_NUL_trans(yy_state_type current_state);
366static int yy_get_next_buffer(void);
367static 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. */
383struct yy_trans_info {
386};
387static 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
399static 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
418static 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
422static 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
436static 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
450static 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
488static 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
526static yy_state_type yy_last_accepting_state;
527static char *yy_last_accepting_cpos;
528
529extern 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
539char *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
546typedef union {
547 double dval;
548 char *str;
549} YYSTYPE;
550
551static YYSTYPE yylval;
552static int lineno;
553static 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
571static int yy_init_globals(void);
572
573/* Accessor methods to globals.
574 These are made visible to non-reentrant scanners for convenience. */
575
577
578int yyget_debug(void);
579
580void yyset_debug(int debug_flag);
581
583
584void yyset_extra(YY_EXTRA_TYPE user_defined);
585
586FILE *yyget_in(void);
587
588void yyset_in(FILE *_in_str);
589
590FILE *yyget_out(void);
591
592void yyset_out(FILE *_out_str);
593
594int yyget_leng(void);
595
596char *yyget_text(void);
597
598int yyget_lineno(void);
599
600void 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
608extern "C" int yywrap(void);
609#else
610extern int yywrap(void);
611#endif
612#endif
613
614#ifndef YY_NO_UNPUT
615
616#endif
617
618#ifndef yytext_ptr
619static void yy_flex_strncpy(char *, yyconst char *, int);
620#endif
621
622#ifdef YY_NEED_STRLEN
623static int yy_flex_strlen(yyconst char *);
624#endif
625
626#ifndef YY_NO_INPUT
627
628#ifdef __cplusplus
629static int yyinput(void);
630#else
631static 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
713extern 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;
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 }
827 case 2:
829#line 31 "hecmw_partlex.l"
830 {
831 len += yyleng;
832 }
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 }
844 case 4:
846#line 34 "hecmw_partlex.l"
847 {
848 len += yyleng;
850 }
852 case 5:
854#line 36 "hecmw_partlex.l"
855 {
856 len += yyleng;
858 }
860 case 6:
862#line 37 "hecmw_partlex.l"
863 {
864 len += yyleng;
866 }
868 case 7:
870#line 38 "hecmw_partlex.l"
871 {
872 len += yyleng;
874 }
876 case 8:
878#line 39 "hecmw_partlex.l"
879 {
880 len += yyleng;
882 }
884 case 9:
886#line 40 "hecmw_partlex.l"
887 {
888 len += yyleng;
889 return HECMW_PARTLEX_K_UCD;
890 }
892 case 10:
894#line 41 "hecmw_partlex.l"
895 {
896 len += yyleng;
898 }
900 case 11:
902#line 43 "hecmw_partlex.l"
903 {
904 len += yyleng;
905 return HECMW_PARTLEX_V_RCB;
906 }
908 case 12:
910#line 44 "hecmw_partlex.l"
911 {
912 len += yyleng;
914 }
916 case 13:
918#line 45 "hecmw_partlex.l"
919 {
920 len += yyleng;
922 }
924 case 14:
926#line 46 "hecmw_partlex.l"
927 {
928 len += yyleng;
930 }
932 case 15:
934#line 47 "hecmw_partlex.l"
935 {
936 len += yyleng;
938 }
940 case 16:
942#line 48 "hecmw_partlex.l"
943 {
944 len += yyleng;
946 }
948 case 17:
950#line 49 "hecmw_partlex.l"
951 {
952 len += yyleng;
954 }
956 case 18:
958#line 50 "hecmw_partlex.l"
959 {
960 len += yyleng;
962 }
964 case 19:
966#line 51 "hecmw_partlex.l"
967 {
968 len += yyleng;
970 }
972 case 20:
974#line 53 "hecmw_partlex.l"
975 {
976 len += yyleng;
977 return '=';
978 }
980 case 21:
982#line 54 "hecmw_partlex.l"
983 {
984 len += yyleng;
985 return ',';
986 }
988 case 22:
990#line 55 "hecmw_partlex.l"
991 {
992 len += yyleng;
993 return 'x';
994 }
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;
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
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 */
1197static 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;
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
1314static 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 */
1342static 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
1367static int yyinput(void)
1368#else
1369static 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
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
1440void 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
1454void 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
1481static 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
1495YY_BUFFER_STATE yy_create_buffer(FILE *file, int size) {
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 */
1536static 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
1590void 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
1616void 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 */
1632static 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
1678YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size) {
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
1713 return yy_scan_bytes(yystr, (int)strlen(yystr));
1714}
1715
1724YY_BUFFER_STATE yy_scan_bytes(yyconst char *yybytes, int _yybytes_len) {
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
1754static 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
1779int yyget_lineno(void) { return yylineno; }
1780
1784FILE *yyget_in(void) { return yyin; }
1785
1789FILE *yyget_out(void) { return yyout; }
1790
1794int yyget_leng(void) { return yyleng; }
1795
1800char *yyget_text(void) { return yytext; }
1801
1806void yyset_lineno(int _line_number) { yylineno = _line_number; }
1807
1814void yyset_in(FILE *_in_str) { yyin = _in_str; }
1815
1816void yyset_out(FILE *_out_str) { yyout = _out_str; }
1817
1818int yyget_debug(void) { return yy_flex_debug; }
1819
1820void yyset_debug(int _bdebug) { yy_flex_debug = _bdebug; }
1821
1822static 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. */
1850int 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
1875static 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
1882static 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
1891void *yyalloc(yy_size_t size) { return malloc(size); }
1892
1893void *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
1904void 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
1912int HECMW_partlex_get_lineno(void) { return lineno; }
1913
1914double HECMW_partlex_get_number(void) { return yylval.dval; }
1915
1916char *HECMW_partlex_get_text(void) { return yytext; }
1917
1918int HECMW_partlex_next_token(void) { return yylex(); }
1919
1920int 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
1928long HECMW_partlex_readsize(void) { return len; }
1929
1930int 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
1944int 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
1952int 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
1963int HECMW_partwrap(void) { return 1; }
unsigned char YY_CHAR
Definition: hecmw_ablex.c:349
short int flex_int16_t
Definition: hecmw_ablex.c:70
#define yyfree
Definition: hecmw_ablex.c:24
#define yyalloc
Definition: hecmw_ablex.c:22
int flex_int32_t
Definition: hecmw_ablex.c:71
int yy_state_type
Definition: hecmw_ablex.c:353
#define yyrealloc
Definition: hecmw_ablex.c:23
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
FILE * yyget_in(void)
#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 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
FILE * yyget_out(void)
#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
#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
#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
void yyset_lineno(int _line_number)
#define YY_DO_BEFORE_ACTION
char * yyget_text(void)
#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
#define YY_DECL
#define yyless(n)
#define YY_BUF_SIZE
#define YY_EXIT_FAILURE
#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
#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
char * HECMW_partlex_get_text(void)
#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