pyscanner.cpp
Go to the documentation of this file.
1 #line 2 "/nova/app/home/novasoft/doxygen/doxygen-1.8.11/build/generated_src/pyscanner.cpp"
2 
3 #line 4 "/nova/app/home/novasoft/doxygen/doxygen-1.8.11/build/generated_src/pyscanner.cpp"
4 
5 #define YY_INT_ALIGNED short int
6 
7 /* A lexical scanner generated by flex */
8 
9 #define yy_create_buffer pyscannerYY_create_buffer
10 #define yy_delete_buffer pyscannerYY_delete_buffer
11 #define yy_flex_debug pyscannerYY_flex_debug
12 #define yy_init_buffer pyscannerYY_init_buffer
13 #define yy_flush_buffer pyscannerYY_flush_buffer
14 #define yy_load_buffer_state pyscannerYY_load_buffer_state
15 #define yy_switch_to_buffer pyscannerYY_switch_to_buffer
16 #define yyin pyscannerYYin
17 #define yyleng pyscannerYYleng
18 #define yylex pyscannerYYlex
19 #define yylineno pyscannerYYlineno
20 #define yyout pyscannerYYout
21 #define yyrestart pyscannerYYrestart
22 #define yytext pyscannerYYtext
23 #define yywrap pyscannerYYwrap
24 #define yyalloc pyscannerYYalloc
25 #define yyrealloc pyscannerYYrealloc
26 #define yyfree pyscannerYYfree
27 
28 #define FLEX_SCANNER
29 #define YY_FLEX_MAJOR_VERSION 2
30 #define YY_FLEX_MINOR_VERSION 5
31 #define YY_FLEX_SUBMINOR_VERSION 35
32 #if YY_FLEX_SUBMINOR_VERSION > 0
33 #define FLEX_BETA
34 #endif
35 
36 /* First, we deal with platform-specific or compiler-specific issues. */
37 
38 /* begin standard C headers. */
39 #include <stdio.h>
40 #include <string.h>
41 #include <errno.h>
42 #include <stdlib.h>
43 
44 /* end standard C headers. */
45 
46 /* flex integer type definitions */
47 
48 #ifndef FLEXINT_H
49 #define FLEXINT_H
50 
51 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
52 
53 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
54 
55 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
56  * if you want the limit (max/min) macros for int types.
57  */
58 #ifndef __STDC_LIMIT_MACROS
59 #define __STDC_LIMIT_MACROS 1
60 #endif
61 
62 #include <inttypes.h>
63 typedef int8_t flex_int8_t;
64 typedef uint8_t flex_uint8_t;
65 typedef int16_t flex_int16_t;
66 typedef uint16_t flex_uint16_t;
67 typedef int32_t flex_int32_t;
68 typedef uint32_t flex_uint32_t;
69 #else
70 typedef signed char flex_int8_t;
71 typedef short int flex_int16_t;
72 typedef int flex_int32_t;
73 typedef unsigned char flex_uint8_t;
74 typedef unsigned short int flex_uint16_t;
75 typedef unsigned int flex_uint32_t;
76 #endif /* ! C99 */
77 
78 /* Limits of integral types. */
79 #ifndef INT8_MIN
80 #define INT8_MIN (-128)
81 #endif
82 #ifndef INT16_MIN
83 #define INT16_MIN (-32767-1)
84 #endif
85 #ifndef INT32_MIN
86 #define INT32_MIN (-2147483647-1)
87 #endif
88 #ifndef INT8_MAX
89 #define INT8_MAX (127)
90 #endif
91 #ifndef INT16_MAX
92 #define INT16_MAX (32767)
93 #endif
94 #ifndef INT32_MAX
95 #define INT32_MAX (2147483647)
96 #endif
97 #ifndef UINT8_MAX
98 #define UINT8_MAX (255U)
99 #endif
100 #ifndef UINT16_MAX
101 #define UINT16_MAX (65535U)
102 #endif
103 #ifndef UINT32_MAX
104 #define UINT32_MAX (4294967295U)
105 #endif
106 
107 #endif /* ! FLEXINT_H */
108 
109 #ifdef __cplusplus
110 
111 /* The "const" storage-class-modifier is valid. */
112 #define YY_USE_CONST
113 
114 #else /* ! __cplusplus */
115 
116 /* C99 requires __STDC__ to be defined as 1. */
117 #if defined (__STDC__)
118 
119 #define YY_USE_CONST
120 
121 #endif /* defined (__STDC__) */
122 #endif /* ! __cplusplus */
123 
124 #ifdef YY_USE_CONST
125 #define yyconst const
126 #else
127 #define yyconst
128 #endif
129 
130 /* Returned upon end-of-file. */
131 #define YY_NULL 0
132 
133 /* Promotes a possibly negative, possibly signed char to an unsigned
134  * integer for use as an array index. If the signed char is negative,
135  * we want to instead treat it as an 8-bit unsigned char, hence the
136  * double cast.
137  */
138 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
139 
140 /* Enter a start condition. This macro really ought to take a parameter,
141  * but we do it the disgusting crufty way forced on us by the ()-less
142  * definition of BEGIN.
143  */
144 #define BEGIN (yy_start) = 1 + 2 *
145 
146 /* Translate the current start state into a value that can be later handed
147  * to BEGIN to return to the state. The YYSTATE alias is for lex
148  * compatibility.
149  */
150 #define YY_START (((yy_start) - 1) / 2)
151 #define YYSTATE YY_START
152 
153 /* Action number for EOF rule of a given start state. */
154 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
155 
156 /* Special action meaning "start processing a new file". */
157 #define YY_NEW_FILE pyscannerYYrestart(pyscannerYYin )
158 
159 #define YY_END_OF_BUFFER_CHAR 0
160 
161 /* Size of default input buffer. */
162 #ifndef YY_BUF_SIZE
163 #define YY_BUF_SIZE 16384
164 #endif
165 
166 /* The state buf must be large enough to hold one state per character in the 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
172 typedef struct yy_buffer_state *YY_BUFFER_STATE;
173 #endif
174 
175 extern int pyscannerYYleng;
176 
177 extern FILE *pyscannerYYin, *pyscannerYYout;
178 
179 #define EOB_ACT_CONTINUE_SCAN 0
180 #define EOB_ACT_END_OF_FILE 1
181 #define EOB_ACT_LAST_MATCH 2
182 
183  #define YY_LESS_LINENO(n)
184 
185 /* Return all but the first "n" matched characters back to the input stream. */
186 #define yyless(n) \
187  do \
188  { \
189  /* Undo effects of setting up pyscannerYYtext. */ \
190  int yyless_macro_arg = (n); \
191  YY_LESS_LINENO(yyless_macro_arg);\
192  *yy_cp = (yy_hold_char); \
193  YY_RESTORE_YY_MORE_OFFSET \
194  (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
195  YY_DO_BEFORE_ACTION; /* set up pyscannerYYtext again */ \
196  } \
197  while ( 0 )
198 
199 #define unput(c) yyunput( c, (yytext_ptr) )
200 
201 #ifndef YY_TYPEDEF_YY_SIZE_T
202 #define YY_TYPEDEF_YY_SIZE_T
203 typedef size_t yy_size_t;
204 #endif
205 
206 #ifndef YY_STRUCT_YY_BUFFER_STATE
207 #define YY_STRUCT_YY_BUFFER_STATE
208 struct yy_buffer_state
209  {
210  FILE *yy_input_file;
211 
212  char *yy_ch_buf; /* input buffer */
213  char *yy_buf_pos; /* current position in input buffer */
214 
215  /* Size of input buffer in bytes, not including room for EOB
216  * characters.
217  */
218  yy_size_t yy_buf_size;
219 
220  /* Number of characters read into yy_ch_buf, not including EOB
221  * characters.
222  */
223  int yy_n_chars;
224 
225  /* Whether we "own" the buffer - i.e., we know we created it,
226  * and can realloc() it to grow it, and should free() it to
227  * delete it.
228  */
229  int yy_is_our_buffer;
230 
231  /* Whether this is an "interactive" input source; if so, and
232  * if we're using stdio for input, then we want to use getc()
233  * instead of fread(), to make sure we stop fetching input after
234  * each newline.
235  */
236  int yy_is_interactive;
237 
238  /* Whether we're considered to be at the beginning of a line.
239  * If so, '^' rules will be active on the next match, otherwise
240  * not.
241  */
242  int yy_at_bol;
243 
244  int yy_bs_lineno; /**< The line count. */
245  int yy_bs_column; /**< The column count. */
246 
247  /* Whether to try to fill the input buffer when we reach the
248  * end of it.
249  */
250  int yy_fill_buffer;
251 
252  int yy_buffer_status;
253 
254 #define YY_BUFFER_NEW 0
255 #define YY_BUFFER_NORMAL 1
256  /* When an EOF's been seen but there's still some text to process
257  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
258  * shouldn't try reading from the input source any more. We might
259  * still have a bunch of tokens to match, though, because of
260  * possible backing-up.
261  *
262  * When we actually see the EOF, we change the status to "new"
263  * (via pyscannerYYrestart()), so that the user can continue scanning by
264  * just pointing pyscannerYYin at a new input file.
265  */
266 #define YY_BUFFER_EOF_PENDING 2
267 
268  };
269 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
270 
271 /* Stack of input buffers. */
272 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
273 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
274 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
275 
276 /* We provide macros for accessing buffer states in case in the
277  * future we want to put the buffer states in a more general
278  * "scanner state".
279  *
280  * Returns the top of the stack, or NULL.
281  */
282 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
283  ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
284  : NULL)
285 
286 /* Same as previous macro, but useful when we know that the buffer stack is not
287  * NULL or when we need an lvalue. For internal use only.
288  */
289 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
290 
291 /* yy_hold_char holds the character lost when pyscannerYYtext is formed. */
292 static char yy_hold_char;
293 static int yy_n_chars; /* number of characters read into yy_ch_buf */
294 int pyscannerYYleng;
295 
296 /* Points to current character in buffer. */
297 static char *yy_c_buf_p = (char *) 0;
298 static int yy_init = 0; /* whether we need to initialize */
299 static int yy_start = 0; /* start state number */
300 
301 /* Flag which is used to allow pyscannerYYwrap()'s to do buffer switches
302  * instead of setting up a fresh pyscannerYYin. A bit of a hack ...
303  */
304 static int yy_did_buffer_switch_on_eof;
305 
306 void pyscannerYYrestart (FILE *input_file );
307 void pyscannerYY_switch_to_buffer (YY_BUFFER_STATE new_buffer );
308 YY_BUFFER_STATE pyscannerYY_create_buffer (FILE *file,int size );
309 void pyscannerYY_delete_buffer (YY_BUFFER_STATE b );
310 void pyscannerYY_flush_buffer (YY_BUFFER_STATE b );
311 void pyscannerYYpush_buffer_state (YY_BUFFER_STATE new_buffer );
312 void pyscannerYYpop_buffer_state (void );
313 
314 static void pyscannerYYensure_buffer_stack (void );
315 static void pyscannerYY_load_buffer_state (void );
316 static void pyscannerYY_init_buffer (YY_BUFFER_STATE b,FILE *file );
317 
318 #define YY_FLUSH_BUFFER pyscannerYY_flush_buffer(YY_CURRENT_BUFFER )
319 
320 YY_BUFFER_STATE pyscannerYY_scan_buffer (char *base,yy_size_t size );
321 YY_BUFFER_STATE pyscannerYY_scan_string (yyconst char *yy_str );
322 YY_BUFFER_STATE pyscannerYY_scan_bytes (yyconst char *bytes,int len );
323 
324 void *pyscannerYYalloc (yy_size_t );
325 void *pyscannerYYrealloc (void *,yy_size_t );
326 void pyscannerYYfree (void * );
327 
328 #define yy_new_buffer pyscannerYY_create_buffer
329 
330 #define yy_set_interactive(is_interactive) \
331  { \
332  if ( ! YY_CURRENT_BUFFER ){ \
333  pyscannerYYensure_buffer_stack (); \
334  YY_CURRENT_BUFFER_LVALUE = \
335  pyscannerYY_create_buffer(pyscannerYYin,YY_BUF_SIZE ); \
336  } \
337  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
338  }
339 
340 #define yy_set_bol(at_bol) \
341  { \
342  if ( ! YY_CURRENT_BUFFER ){\
343  pyscannerYYensure_buffer_stack (); \
344  YY_CURRENT_BUFFER_LVALUE = \
345  pyscannerYY_create_buffer(pyscannerYYin,YY_BUF_SIZE ); \
346  } \
347  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
348  }
349 
350 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
351 
352 /* Begin user sect3 */
353 
354 #define pyscannerYYwrap(n) 1
355 #define YY_SKIP_YYWRAP
356 
357 typedef unsigned char YY_CHAR;
358 
359 FILE *pyscannerYYin = (FILE *) 0, *pyscannerYYout = (FILE *) 0;
360 
361 typedef int yy_state_type;
362 
363 extern int pyscannerYYlineno;
364 
365 int pyscannerYYlineno = 1;
366 
367 extern char *pyscannerYYtext;
368 #define yytext_ptr pyscannerYYtext
369 
370 static yy_state_type yy_get_previous_state (void );
371 static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
372 static int yy_get_next_buffer (void );
373 static void yy_fatal_error (yyconst char msg[] );
374 
375 /* Done after the current pattern has been matched and before the
376  * corresponding action - sets up pyscannerYYtext.
377  */
378 #define YY_DO_BEFORE_ACTION \
379  (yytext_ptr) = yy_bp; \
380  pyscannerYYleng = (size_t) (yy_cp - yy_bp); \
381  (yy_hold_char) = *yy_cp; \
382  *yy_cp = '\0'; \
383  (yy_c_buf_p) = yy_cp;
384 
385 #define YY_NUM_RULES 163
386 #define YY_END_OF_BUFFER 164
387 /* This struct is not used in this scanner,
388  but its presence is necessary. */
389 struct yy_trans_info
390  {
391  flex_int32_t yy_verify;
392  flex_int32_t yy_nxt;
393  };
394 static yyconst flex_int16_t yy_acclist[881] =
395  { 0,
396  16488,16488, 106, 106, 30, 30, 36, 36, 41, 41,
397  164, 162, 163, 161, 163, 25, 162, 163, 25, 162,
398  163, 19, 161, 163, 13, 25, 162, 163, 25, 162,
399  163, 12, 25, 162, 163, 23, 25, 162, 163, 24,
400  25, 162, 163, 25, 162, 163, 17, 25, 162, 163,
401  16395, 17, 25, 162, 163,16395, 17, 25, 162, 163,
402  16395, 17, 25, 162, 163,16395, 17, 25, 162, 163,
403  16395, 18, 25, 162, 163, 17, 25, 162, 163,16393,
404  16394,16395, 17, 25, 162, 163,16393,16394,16395, 17,
405  25, 162, 163,16393,16394,16395, 17, 25, 162, 163,
406 
407  16393,16394,16395, 17, 25, 162, 163,16393,16394,16395,
408  53, 54, 162, 163, 51, 161, 163, 50, 54, 162,
409  163, 54, 162, 163, 49, 54, 162, 163, 54, 162,
410  163, 52, 54, 162, 163, 52, 54, 162, 163, 52,
411  54, 162, 163, 52, 53, 54, 162, 163, 135, 138,
412  162, 163, 138, 162, 163, 136, 161, 163, 138, 162,
413  163, 138, 162, 163, 138, 162, 163, 134, 138, 162,
414  163, 141, 143, 162, 163, 142, 161, 163, 143, 162,
415  163, 141, 143, 162, 163, 139, 143, 162, 163, 162,
416  163, 71, 162, 163, 70, 162, 163, 69, 162, 163,
417 
418  78, 162, 163, 72, 162, 163, 78, 162, 163, 75,
419  162, 163, 72, 78, 162, 163, 76, 162, 163, 74,
420  78, 162, 163, 73, 78, 162, 163, 61, 65, 162,
421  163, 65, 162, 163, 64, 161, 163,16439, 60, 65,
422  162, 163, 63, 65, 162, 163, 59, 65, 162, 163,
423  58, 65, 162, 163, 63, 65, 162, 163, 82, 162,
424  163, 83, 161, 163, 79, 82, 162, 163, 81, 82,
425  162, 163, 80, 82, 162, 163, 96, 162, 163, 97,
426  162, 163, 97, 162, 163, 98, 162, 163, 99, 162,
427  163, 162, 163, 100, 161, 163, 8296, 162, 163, 162,
428 
429  163, 162, 163, 103, 162, 163, 90, 93, 162, 163,
430  93, 162, 163, 91, 161, 163, 89, 93, 162, 163,
431  93, 162, 163, 88, 93, 162, 163, 87, 93, 162,
432  163, 119, 162, 163, 106, 119, 162, 163, 120, 161,
433  163, 111, 119, 162, 163, 117, 119, 162, 163, 110,
434  119, 162, 163, 114, 119, 162, 163, 107, 119, 162,
435  163, 107, 119, 162, 163, 105, 119, 162, 163, 118,
436  119, 162, 163, 118, 119, 162, 163, 118, 119, 162,
437  163, 118, 119, 162, 163, 118, 119, 162, 163, 115,
438  119, 162, 163, 118, 119, 162, 163, 116, 119, 162,
439 
440  163, 131, 162, 163, 130, 161, 163, 128, 162, 163,
441  129, 161, 163, 126, 128, 162, 163, 125, 128, 162,
442  163, 121, 128, 162, 163, 122, 128, 162, 163, 127,
443  128, 162, 163, 148, 149, 162, 163, 149, 162, 163,
444  147, 149, 162, 163, 149, 162, 163, 154, 155, 162,
445  163, 153, 155, 162, 163, 155, 162, 163, 155, 162,
446  163, 158, 160, 162, 163, 158, 159, 161, 163, 158,
447  160, 162, 163, 158, 160, 162, 163, 160, 162, 163,
448  31, 162, 163, 30, 31, 162, 163, 29, 161, 163,
449  26, 31, 162, 163, 27, 31, 162, 163, 27, 31,
450 
451  162, 163, 38, 162, 163, 36, 38, 162, 163, 35,
452  161, 163, 32, 38, 162, 163, 37, 38, 162, 163,
453  34, 38, 162, 163,16417, 42, 162, 163, 41, 42,
454  162, 163, 40, 161, 163, 39, 42, 162, 163,16395,
455  19, 16, 15, 16, 17,16395, 17,16395, 17,16395,
456  17,16395, 17,16395, 18,16393,16394,16395,16393,16394,
457  16395,16393,16394,16395,16393,16394,16395,16393,16394,16395,
458  17,16393,16394,16395, 17,16393,16394,16395, 17,16393,
459  16394,16395, 17,16393,16394,16395, 17,16393,16394,16395,
460  53, 48, 52, 52, 52, 52, 53, 135, 137, 134,
461 
462  141, 140, 141, 139, 139, 71, 70, 69, 72, 77,
463  76, 73, 61,16439, 63, 63, 58, 57, 62, 63,
464  96, 97, 99, 100, 103, 90, 92, 87, 86, 106,
465  117, 107, 107, 107, 118, 118, 111, 110, 118, 118,
466  127, 148, 145, 145, 144, 154, 151, 151, 150, 158,
467  158, 158, 30, 27, 27, 36, 8225, 34,16417, 41,
468  39,16395, 20, 16, 15, 16, 22, 21, 8203, 17,
469  16395, 17,16395, 17,16395, 17,16395,16393,16394,16395,
470  16393,16394,16395,16393,16394,16395,16393,16394,16395,16393,
471  16394,16395, 8202, 8203, 8202, 8203, 8202, 8203, 17,16393,
472 
473  16394,16395, 17,16393,16394,16395, 17,16393,16394,16395,
474  17,16393,16394,16395, 45, 48, 47, 46, 52, 52,
475  132, 133, 77, 56, 8247, 66, 63, 68, 68, 67,
476  62, 63, 99, 101, 102, 84, 94, 92, 95, 112,
477  113, 108, 107, 107, 118, 118, 123, 124, 146, 152,
478  156, 157, 27, 27, 8225, 39, 20, 21, 17,16395,
479  2, 17,16395, 17,16395,16393,16394,16395,16393,16394,
480  16395,16393,16394,16395,16393,16394,16395, 17,16393,16394,
481  16395, 1, 2, 17,16393,16394,16395, 17,16393,16394,
482  16395, 45, 46, 52, 132, 133, 66, 67, 99, 101,
483 
484  102, 85, 94, 95, 112, 113, 108, 107, 118, 109,
485  118, 123, 124, 156, 157, 27, 27, 39, 17,16395,
486  6, 17,16395,16393,16394,16395, 1,16393,16394,16395,
487  16393,16394,16395, 17,16393,16394,16395, 5, 6, 17,
488  16393,16394,16395,16428, 108, 27, 4, 17,16395,16393,
489  16394,16395, 5,16393,16394,16395, 3, 4, 17,16393,
490  16394,16395,16428, 8236,16427, 27, 28, 8, 3,16393,
491  16394,16395, 7, 8,16427, 8235, 28, 7, 8201, 14
492  } ;
493 
494 static yyconst flex_int16_t yy_accept[497] =
495  { 0,
496  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
497  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
498  1, 1, 1, 1, 1, 2, 3, 3, 3, 4,
499  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
500  5, 6, 7, 8, 9, 10, 11, 12, 14, 16,
501  19, 22, 25, 29, 32, 36, 40, 44, 47, 52,
502  57, 62, 67, 72, 76, 83, 90, 97, 104, 111,
503  115, 118, 122, 125, 129, 132, 136, 140, 144, 149,
504  153, 156, 159, 162, 165, 168, 172, 176, 179, 182,
505  186, 190, 192, 195, 198, 201, 204, 207, 210, 213,
506 
507  217, 220, 224, 228, 232, 235, 239, 243, 247, 251,
508  255, 259, 262, 265, 269, 273, 277, 280, 283, 286,
509  289, 292, 294, 297, 300, 302, 304, 307, 311, 314,
510  317, 321, 324, 328, 332, 335, 339, 342, 346, 350,
511  354, 358, 362, 366, 370, 374, 378, 382, 386, 390,
512  394, 398, 402, 405, 408, 411, 414, 418, 422, 426,
513  430, 434, 438, 441, 445, 448, 452, 456, 459, 462,
514  466, 470, 474, 478, 481, 484, 488, 491, 495, 499,
515  503, 506, 510, 513, 517, 521, 526, 529, 533, 536,
516  540, 540, 541, 542, 542, 543, 545, 545, 545, 545,
517 
518  545, 545, 545, 547, 547, 549, 551, 553, 555, 556,
519  559, 562, 565, 568, 571, 571, 575, 575, 579, 583,
520  587, 591, 592, 592, 593, 593, 593, 594, 595, 596,
521  598, 599, 599, 599, 600, 601, 602, 602, 603, 604,
522  605, 606, 606, 607, 608, 609, 610, 611, 612, 613,
523  614, 615, 615, 615, 615, 616, 617, 617, 618, 619,
524  621, 622, 623, 623, 624, 624, 625, 625, 625, 626,
525  627, 627, 627, 627, 628, 628, 629, 630, 631, 631,
526  632, 632, 632, 633, 634, 635, 635, 636, 637, 638,
527  639, 640, 641, 641, 641, 642, 643, 643, 644, 645,
528 
529  646, 647, 647, 648, 649, 650, 651, 651, 652, 653,
530  654, 654, 654, 655, 656, 657, 657, 658, 660, 661,
531  661, 661, 662, 663, 664, 665, 667, 668, 669, 669,
532  669, 669, 669, 670, 672, 674, 676, 678, 681, 684,
533  687, 690, 693, 695, 697, 699, 703, 707, 711, 715,
534  716, 717, 718, 719, 720, 721, 722, 723, 724, 725,
535  726, 726, 727, 729, 730, 731, 733, 734, 735, 736,
536  736, 737, 737, 738, 739, 740, 741, 742, 743, 744,
537  745, 746, 747, 748, 749, 750, 750, 751, 751, 752,
538  753, 753, 754, 755, 756, 756, 757, 758, 759, 759,
539 
540  759, 761, 762, 764, 766, 769, 772, 775, 778, 778,
541  778, 778, 782, 784, 788, 792, 793, 794, 794, 795,
542  796, 797, 798, 799, 800, 801, 802, 803, 804, 805,
543  806, 807, 807, 808, 809, 810, 812, 813, 814, 815,
544  816, 817, 818, 819, 819, 821, 822, 824, 827, 828,
545  831, 834, 834, 838, 840, 844, 845, 845, 845, 846,
546  847, 847, 848, 850, 853, 854, 857, 857, 859, 863,
547  863, 864, 865, 866, 868, 868, 869, 870, 873, 873,
548  875, 875, 876, 877, 878, 878, 879, 879, 879, 879,
549  879, 880, 880, 880, 881, 881
550 
551  } ;
552 
553 static yyconst flex_int32_t yy_ec[256] =
554  { 0,
555  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
556  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
557  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
558  1, 2, 4, 5, 6, 1, 7, 7, 8, 9,
559  10, 11, 12, 13, 12, 14, 7, 15, 16, 16,
560  16, 16, 16, 16, 16, 17, 17, 18, 7, 7,
561  19, 7, 1, 20, 21, 21, 21, 21, 22, 23,
562  24, 24, 24, 25, 24, 26, 24, 24, 24, 24,
563  24, 27, 24, 28, 29, 24, 24, 30, 24, 24,
564  31, 32, 33, 1, 34, 7, 35, 21, 36, 37,
565 
566  38, 39, 24, 40, 41, 25, 24, 42, 43, 24,
567  44, 45, 24, 46, 47, 48, 49, 24, 24, 30,
568  50, 24, 51, 7, 33, 7, 1, 52, 52, 52,
569  52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
570  52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
571  52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
572  52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
573  52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
574  52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
575  52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
576 
577  52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
578  52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
579  52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
580  52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
581  52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
582  52, 52, 52, 52, 52
583  } ;
584 
585 static yyconst flex_int32_t yy_meta[53] =
586  { 0,
587  1, 2, 3, 1, 4, 5, 1, 4, 1, 6,
588  1, 1, 7, 8, 9, 9, 9, 1, 10, 1,
589  11, 11, 11, 12, 12, 12, 12, 12, 12, 12,
590  1, 13, 1, 12, 11, 11, 11, 11, 11, 12,
591  12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
592  1, 14
593  } ;
594 
595 static yyconst flex_int16_t yy_base[603] =
596  { 0,
597  1766, 1763, 0, 52, 104, 0, 1760, 1756, 155, 159,
598  162, 167, 191, 0, 243, 0, 169, 176, 293, 295,
599  308, 0, 360, 0, 412, 420, 428, 436, 444, 0,
600  1753, 1740, 496, 0, 546, 547, 553, 554, 560, 561,
601  593, 0, 645, 0, 697, 0, 1729, 2672, 2672, 2672,
602  1723, 1719, 1716, 182, 1712, 2672, 2672, 1672, 416, 748,
603  749, 750, 762, 752, 570, 764, 763, 784, 797, 0,
604  2672, 1713, 1710, 1707, 2672, 0, 1665, 1666, 840, 0,
605  2672, 2672, 1698, 1694, 0, 1699, 0, 174, 2672, 183,
606  1692, 558, 2672, 2672, 0, 2672, 1693, 0, 2672, 2672,
607 
608  1682, 2672, 0, 0, 2672, 295, 1677, 1672, 1667, 297,
609  1658, 2672, 2672, 2672, 2672, 2672, 0, 1660, 2672, 2672,
610  1634, 568, 2672, 2672, 1639, 1627, 571, 0, 2672, 1628,
611  1628, 0, 1622, 579, 2672, 1625, 2672, 1609, 0, 1601,
612  2672, 879, 797, 2672, 0, 1573, 411, 1559, 790, 2672,
613  816, 2672, 2672, 2672, 2672, 2672, 1597, 1593, 2672, 2672,
614  0, 0, 1595, 2672, 585, 0, 2672, 1588, 588, 1559,
615  1556, 1582, 1578, 823, 2672, 1581, 2672, 2672, 778, 818,
616  2672, 1578, 2672, 2672, 2672, 802, 2672, 1577, 2672, 823,
617  1576, 864, 1574, 1571, 0, 0, 0, 1567, 1526, 865,
618 
619  844, 1571, 866, 0, 887, 888, 900, 901, 897, 913,
620  929, 939, 941, 943, 953, 955, 755, 957, 971, 978,
621  983, 0, 1565, 0, 0, 1557, 0, 1515, 1519, 1028,
622  0, 1555, 1539, 2672, 1541, 0, 827, 2672, 832, 1534,
623  1533, 800, 2672, 2672, 0, 1536, 0, 1535, 0, 0,
624  863, 1530, 1533, 1529, 0, 421, 1525, 753, 2672, 0,
625  0, 1373, 0, 1360, 768, 2672, 1368, 1364, 776, 0,
626  1363, 1364, 1357, 0, 1353, 782, 2672, 1354, 1348, 0,
627  1344, 865, 989, 1039, 2672, 0, 0, 1306, 2672, 2672,
628  1290, 840, 1333, 1329, 0, 0, 1323, 2672, 884, 2672,
629 
630  0, 1317, 2672, 914, 2672, 1292, 932, 1318, 1312, 1308,
631  910, 1307, 916, 980, 1304, 806, 1301, 948, 1292, 981,
632  1286, 987, 998, 1282, 0, 0, 2672, 1278, 1244, 906,
633  1274, 1014, 2672, 1056, 1072, 1074, 1076, 1086, 1088, 1100,
634  1102, 1112, 2672, 825, 1229, 1114, 1116, 1128, 1130, 1270,
635  0, 2672, 1265, 1251, 984, 1244, 1243, 0, 2672, 1239,
636  1236, 1230, 0, 2672, 1225, 0, 1194, 1185, 1184, 0,
637  1181, 1158, 1154, 0, 1146, 1140, 1133, 1137, 2672, 992,
638  1089, 1070, 1088, 1073, 2672, 926, 2672, 976, 1069, 1064,
639  1061, 1005, 1007, 1055, 1050, 1048, 2672, 2672, 1001, 1132,
640 
641  1153, 1154, 1166, 1167, 1168, 1180, 1182, 1192, 967, 996,
642  992, 1204, 1208, 1218, 1220, 2672, 2672, 0, 1012, 2672,
643  2672, 2672, 2672, 1006, 2672, 2672, 2672, 2672, 2672, 2672,
644  2672, 1055, 2672, 2672, 975, 0, 2672, 2672, 2672, 2672,
645  1092, 1189, 1095, 958, 1230, 1240, 1242, 1244, 1254, 1258,
646  1268, 930, 1270, 1282, 1283, 945, 0, 1181, 1282, 1210,
647  852, 1298, 1302, 1303, 1316, 1317, 826, 1330, 1331, 1081,
648  1109, 2672, 1146, 1202, 792, 1332, 1344, 1345, 707, 1357,
649  1207, 1243, 2672, 1205, 546, 1358, 505, 395, 387, 267,
650  2672, 122, 122, 2672, 2672, 1377, 1391, 1405, 1419, 1433,
651 
652  1447, 1461, 1475, 1489, 1503, 1517, 1530, 1544, 1557, 1570,
653  1583, 1597, 1611, 1617, 1631, 1645, 1659, 1665, 1679, 1685,
654  1699, 1712, 1726, 1740, 1746, 1753, 1767, 1777, 1791, 1805,
655  1811, 1817, 1831, 1845, 1859, 1873, 1887, 1900, 1913, 1926,
656  1939, 1953, 1967, 1981, 1994, 2007, 2021, 2034, 2047, 2060,
657  2074, 2088, 2102, 2116, 2122, 2136, 2150, 2156, 2170, 2176,
658  2190, 2203, 2216, 2230, 2244, 2258, 2264, 2268, 2275, 2289,
659  2302, 2316, 2330, 566, 2336, 2342, 2356, 2370, 2384, 2397,
660  2410, 2423, 2436, 2449, 2462, 2476, 2490, 2503, 2516, 2529,
661  2542, 2555, 2569, 2576, 2583, 2597, 2610, 2623, 2627, 2640,
662 
663  2644, 2657
664  } ;
665 
666 static yyconst flex_int16_t yy_def[603] =
667  { 0,
668  496, 496, 495, 495, 495, 5, 496, 496, 497, 497,
669  498, 498, 495, 13, 495, 15, 499, 499, 500, 500,
670  495, 21, 495, 23, 501, 501, 502, 502, 495, 29,
671  503, 503, 495, 33, 504, 504, 505, 505, 506, 506,
672  495, 41, 495, 43, 495, 45, 495, 495, 495, 495,
673  507, 495, 495, 508, 495, 495, 495, 495, 509, 509,
674  509, 509, 509, 510, 511, 511, 511, 511, 511, 512,
675  495, 495, 513, 495, 495, 514, 514, 514, 514, 515,
676  495, 495, 495, 495, 516, 495, 517, 495, 495, 517,
677  495, 495, 495, 495, 518, 495, 495, 519, 495, 495,
678 
679  495, 495, 520, 521, 495, 522, 495, 523, 495, 495,
680  524, 495, 495, 495, 495, 495, 525, 495, 495, 495,
681  526, 495, 495, 495, 495, 495, 495, 527, 495, 528,
682  495, 529, 495, 495, 495, 495, 495, 495, 530, 495,
683  495, 495, 495, 495, 531, 531, 531, 531, 531, 495,
684  531, 495, 495, 495, 495, 495, 495, 495, 495, 495,
685  532, 533, 495, 495, 534, 535, 495, 495, 536, 537,
686  537, 495, 495, 537, 495, 495, 495, 495, 538, 538,
687  495, 495, 495, 495, 495, 539, 495, 495, 495, 540,
688  507, 541, 495, 495, 542, 543, 544, 495, 495, 495,
689 
690  495, 545, 546, 547, 546, 546, 546, 546, 548, 549,
691  549, 549, 549, 549, 495, 550, 551, 550, 550, 550,
692  550, 552, 495, 553, 554, 495, 555, 555, 555, 555,
693  556, 495, 495, 495, 495, 557, 495, 495, 557, 495,
694  495, 495, 495, 495, 558, 495, 559, 495, 560, 561,
695  562, 495, 563, 495, 564, 565, 495, 495, 495, 566,
696  567, 495, 568, 569, 495, 495, 495, 495, 495, 570,
697  495, 571, 495, 572, 495, 495, 495, 495, 495, 573,
698  495, 495, 495, 495, 495, 574, 575, 575, 495, 495,
699  575, 575, 495, 495, 576, 577, 495, 495, 495, 495,
700 
701  578, 495, 495, 495, 495, 579, 579, 495, 495, 495,
702  495, 580, 581, 581, 495, 495, 495, 582, 495, 495,
703  583, 584, 585, 495, 586, 587, 495, 495, 495, 495,
704  588, 589, 495, 590, 590, 590, 590, 591, 591, 591,
705  591, 591, 495, 495, 495, 592, 592, 592, 592, 495,
706  593, 495, 495, 594, 594, 495, 495, 559, 495, 495,
707  563, 495, 564, 495, 495, 566, 595, 495, 495, 596,
708  495, 571, 495, 572, 495, 495, 495, 495, 495, 574,
709  575, 575, 495, 495, 495, 495, 495, 495, 495, 495,
710  580, 597, 581, 495, 583, 598, 495, 495, 495, 589,
711 
712  590, 495, 590, 590, 591, 591, 591, 591, 495, 495,
713  495, 592, 495, 592, 592, 495, 495, 599, 594, 495,
714  495, 495, 495, 595, 495, 495, 495, 495, 495, 495,
715  495, 495, 495, 495, 575, 575, 495, 495, 495, 495,
716  597, 581, 598, 495, 590, 495, 590, 591, 495, 591,
717  591, 495, 592, 495, 592, 600, 601, 495, 495, 581,
718  495, 495, 590, 591, 495, 591, 495, 495, 592, 495,
719  600, 495, 602, 581, 495, 495, 495, 591, 495, 495,
720  495, 602, 495, 495, 495, 495, 495, 495, 495, 495,
721  495, 495, 495, 495, 0, 495, 495, 495, 495, 495,
722 
723  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
724  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
725  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
726  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
727  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
728  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
729  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
730  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
731  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
732  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
733 
734  495, 495
735  } ;
736 
737 static yyconst flex_int16_t yy_nxt[2725] =
738  { 0,
739  50, 51, 52, 50, 53, 54, 50, 55, 56, 57,
740  50, 50, 50, 50, 50, 50, 50, 50, 50, 58,
741  59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
742  50, 50, 50, 59, 59, 60, 61, 59, 62, 59,
743  63, 59, 59, 59, 59, 59, 59, 59, 59, 59,
744  50, 59, 50, 64, 52, 50, 53, 54, 50, 55,
745  56, 57, 50, 50, 50, 50, 50, 50, 50, 50,
746  50, 58, 65, 65, 65, 65, 65, 65, 65, 65,
747  65, 65, 50, 50, 50, 65, 65, 66, 67, 65,
748  68, 65, 69, 65, 65, 65, 65, 65, 65, 65,
749 
750  65, 65, 50, 65, 70, 70, 71, 70, 72, 73,
751  70, 74, 70, 70, 70, 70, 70, 75, 70, 70,
752  70, 70, 70, 70, 76, 76, 76, 76, 76, 76,
753  76, 76, 76, 76, 70, 70, 70, 76, 76, 77,
754  76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
755  78, 76, 76, 76, 70, 79, 81, 82, 494, 83,
756  86, 82, 84, 83, 88, 493, 84, 89, 90, 88,
757  105, 106, 91, 107, 108, 237, 109, 110, 106, 238,
758  107, 111, 105, 109, 239, 196, 85, 197, 240, 105,
759  85, 48, 92, 49, 48, 48, 48, 48, 48, 93,
760 
761  48, 48, 48, 48, 48, 48, 48, 48, 94, 48,
762  48, 95, 95, 95, 95, 95, 95, 95, 95, 95,
763  95, 48, 48, 48, 95, 95, 95, 95, 95, 95,
764  95, 95, 95, 95, 95, 95, 95, 95, 95, 95,
765  95, 48, 95, 96, 97, 49, 96, 96, 98, 96,
766  96, 48, 99, 96, 96, 100, 96, 96, 96, 96,
767  101, 102, 96, 103, 103, 103, 103, 103, 103, 103,
768  103, 103, 103, 96, 96, 96, 103, 103, 103, 103,
769  103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
770  103, 103, 103, 96, 103, 113, 251, 113, 258, 259,
771 
772  252, 114, 115, 114, 115, 116, 492, 116, 48, 48,
773  49, 48, 48, 48, 48, 48, 48, 48, 48, 48,
774  48, 48, 48, 48, 48, 48, 48, 48, 117, 117,
775  117, 117, 117, 117, 117, 117, 117, 117, 48, 48,
776  48, 117, 117, 117, 117, 117, 117, 117, 117, 117,
777  117, 117, 117, 117, 117, 117, 117, 117, 48, 117,
778  48, 118, 49, 48, 48, 48, 48, 48, 119, 119,
779  48, 48, 119, 48, 48, 48, 48, 120, 48, 48,
780  121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
781  48, 48, 48, 121, 121, 121, 121, 121, 121, 121,
782 
783  121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
784  48, 121, 48, 122, 123, 289, 125, 200, 290, 126,
785  48, 127, 123, 364, 125, 201, 255, 126, 202, 129,
786  130, 48, 131, 132, 204, 133, 491, 134, 130, 48,
787  131, 132, 490, 133, 135, 136, 137, 135, 138, 139,
788  135, 140, 141, 135, 135, 135, 135, 135, 142, 143,
789  143, 135, 144, 135, 145, 145, 146, 145, 145, 145,
790  147, 148, 149, 145, 150, 135, 135, 145, 145, 145,
791  145, 145, 145, 145, 145, 145, 145, 145, 145, 147,
792  145, 145, 151, 145, 152, 145, 155, 155, 156, 155,
793 
794  157, 155, 155, 158, 159, 160, 155, 155, 155, 155,
795  155, 155, 155, 155, 155, 155, 161, 161, 161, 161,
796  161, 161, 161, 161, 161, 161, 159, 155, 160, 161,
797  161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
798  161, 161, 161, 161, 161, 161, 159, 161, 49, 49,
799  163, 163, 489, 164, 164, 49, 49, 167, 167, 242,
800  168, 168, 171, 171, 172, 172, 243, 173, 173, 265,
801  266, 215, 269, 266, 380, 244, 380, 165, 165, 201,
802  276, 277, 202, 488, 169, 169, 299, 300, 217, 304,
803  305, 174, 174, 175, 176, 177, 175, 175, 175, 175,
804 
805  175, 175, 175, 175, 175, 175, 178, 175, 175, 175,
806  175, 175, 175, 179, 179, 179, 179, 179, 179, 179,
807  179, 179, 179, 175, 175, 175, 179, 179, 179, 179,
808  179, 179, 179, 180, 179, 179, 179, 179, 179, 179,
809  179, 179, 179, 175, 179, 181, 182, 183, 181, 181,
810  181, 181, 181, 181, 181, 184, 181, 185, 181, 181,
811  181, 181, 181, 181, 181, 186, 186, 186, 186, 186,
812  186, 186, 186, 186, 186, 181, 181, 181, 186, 186,
813  186, 186, 186, 186, 186, 186, 186, 186, 186, 186,
814  186, 186, 186, 186, 186, 181, 186, 187, 188, 189,
815 
816  187, 187, 187, 187, 187, 187, 187, 187, 187, 187,
817  187, 187, 187, 187, 187, 187, 187, 190, 190, 190,
818  190, 190, 190, 190, 190, 190, 190, 187, 187, 187,
819  190, 190, 190, 190, 190, 190, 190, 190, 190, 190,
820  190, 190, 190, 190, 190, 190, 190, 187, 190, 200,
821  200, 200, 487, 209, 258, 259, 344, 201, 201, 201,
822  202, 202, 202, 200, 215, 215, 204, 204, 204, 265,
823  266, 201, 201, 201, 202, 202, 202, 269, 266, 311,
824  204, 217, 217, 276, 277, 215, 206, 211, 212, 205,
825  213, 312, 214, 201, 289, 207, 202, 290, 215, 345,
826 
827  219, 242, 217, 316, 208, 218, 201, 316, 243, 202,
828  282, 284, 284, 284, 317, 217, 292, 244, 317, 311,
829  289, 285, 285, 290, 320, 495, 409, 306, 237, 220,
830  306, 312, 238, 239, 485, 292, 321, 240, 285, 221,
831  222, 222, 292, 222, 289, 330, 222, 290, 222, 222,
832  222, 222, 222, 201, 230, 230, 230, 222, 222, 222,
833  314, 292, 204, 479, 251, 200, 200, 200, 252, 410,
834  222, 222, 222, 201, 201, 201, 202, 202, 202, 378,
835  378, 378, 204, 204, 204, 386, 300, 475, 200, 200,
836  222, 230, 282, 283, 283, 284, 201, 201, 209, 202,
837 
838  202, 200, 200, 285, 285, 204, 204, 330, 286, 201,
839  201, 311, 202, 202, 215, 388, 305, 311, 204, 204,
840  285, 334, 201, 312, 204, 202, 335, 386, 300, 312,
841  215, 217, 211, 212, 495, 213, 306, 214, 201, 306,
842  215, 202, 215, 336, 215, 337, 470, 217, 201, 316,
843  201, 202, 201, 202, 215, 202, 215, 217, 215, 217,
844  317, 217, 201, 472, 201, 202, 201, 202, 409, 202,
845  339, 217, 215, 217, 467, 217, 340, 388, 305, 215,
846  201, 311, 320, 202, 215, 342, 341, 201, 320, 217,
847  202, 346, 201, 312, 321, 202, 217, 495, 461, 200,
848 
849  321, 217, 282, 283, 283, 284, 311, 201, 311, 347,
850  202, 410, 436, 285, 379, 200, 204, 434, 312, 263,
851  312, 348, 419, 201, 393, 457, 202, 349, 222, 222,
852  379, 222, 204, 434, 222, 452, 222, 222, 222, 222,
853  222, 411, 230, 230, 230, 222, 222, 222, 444, 320,
854  442, 395, 282, 284, 284, 284, 394, 200, 222, 222,
855  222, 321, 391, 285, 285, 201, 458, 440, 202, 459,
856  459, 459, 439, 402, 204, 200, 438, 200, 222, 230,
857  285, 201, 470, 201, 202, 201, 202, 215, 202, 215,
858  204, 437, 204, 311, 204, 201, 320, 201, 202, 472,
859 
860  202, 215, 401, 215, 217, 312, 217, 436, 321, 201,
861  470, 201, 202, 215, 202, 215, 403, 413, 217, 404,
862  217, 201, 405, 201, 202, 201, 202, 472, 202, 215,
863  217, 215, 217, 200, 217, 435, 431, 201, 406, 201,
864  202, 201, 202, 430, 202, 407, 217, 481, 217, 429,
865  204, 378, 378, 378, 200, 402, 408, 428, 432, 371,
866  412, 433, 201, 201, 483, 202, 202, 446, 200, 215,
867  414, 204, 204, 415, 432, 201, 201, 201, 202, 202,
868  202, 449, 371, 215, 204, 204, 217, 426, 425, 201,
869  311, 201, 202, 215, 202, 459, 459, 459, 217, 445,
870 
871  217, 201, 312, 484, 202, 215, 484, 263, 481, 413,
872  217, 311, 447, 201, 448, 312, 202, 201, 312, 454,
873  202, 215, 217, 312, 450, 483, 217, 201, 423, 201,
874  202, 462, 202, 422, 460, 451, 217, 360, 217, 201,
875  360, 446, 202, 200, 481, 215, 421, 420, 204, 201,
876  453, 201, 202, 201, 202, 449, 202, 474, 204, 465,
877  204, 483, 217, 201, 418, 455, 202, 201, 417, 215,
878  202, 468, 217, 416, 411, 331, 217, 201, 399, 201,
879  202, 398, 202, 454, 215, 397, 217, 395, 217, 463,
880  464, 201, 201, 319, 202, 202, 459, 459, 459, 462,
881 
882  217, 217, 394, 476, 477, 315, 433, 201, 391, 310,
883  202, 201, 201, 466, 202, 202, 204, 465, 215, 390,
884  204, 217, 389, 307, 387, 201, 201, 385, 202, 202,
885  469, 468, 480, 476, 217, 217, 384, 383, 382, 201,
886  201, 201, 202, 202, 202, 477, 486, 381, 217, 217,
887  204, 377, 376, 201, 201, 278, 202, 202, 480, 486,
888  375, 373, 217, 217, 478, 371, 201, 201, 370, 202,
889  202, 369, 368, 263, 262, 217, 217, 48, 48, 48,
890  48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
891  48, 80, 80, 80, 80, 80, 80, 80, 80, 80,
892 
893  80, 80, 80, 80, 80, 87, 87, 87, 87, 87,
894  87, 87, 87, 87, 87, 87, 87, 87, 87, 104,
895  104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
896  104, 104, 104, 112, 112, 112, 112, 112, 112, 112,
897  112, 112, 112, 112, 112, 112, 112, 124, 124, 124,
898  124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
899  124, 128, 128, 128, 128, 128, 128, 128, 128, 128,
900  128, 128, 128, 128, 128, 153, 153, 153, 153, 153,
901  153, 153, 153, 153, 153, 153, 153, 153, 153, 162,
902  162, 162, 162, 162, 162, 162, 162, 162, 162, 162,
903 
904  162, 162, 162, 166, 166, 166, 166, 166, 166, 166,
905  166, 166, 166, 166, 166, 166, 166, 170, 170, 170,
906  170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
907  170, 192, 365, 362, 360, 359, 248, 246, 241, 241,
908  192, 192, 235, 192, 195, 195, 357, 195, 195, 195,
909  195, 195, 195, 195, 195, 195, 195, 195, 203, 356,
910  355, 354, 203, 203, 353, 203, 203, 203, 203, 350,
911  203, 210, 331, 329, 328, 324, 193, 191, 319, 315,
912  210, 210, 310, 210, 216, 309, 308, 307, 216, 216,
913  307, 216, 216, 216, 216, 302, 216, 222, 222, 297,
914 
915  294, 293, 222, 222, 291, 222, 222, 288, 281, 222,
916  222, 224, 224, 279, 224, 224, 224, 224, 224, 224,
917  224, 224, 224, 224, 224, 227, 278, 227, 227, 275,
918  227, 231, 273, 271, 268, 231, 231, 231, 231, 231,
919  231, 231, 231, 267, 231, 234, 234, 263, 234, 234,
920  234, 234, 234, 234, 234, 234, 234, 234, 234, 236,
921  236, 262, 236, 256, 236, 236, 236, 236, 236, 236,
922  236, 236, 236, 245, 257, 245, 245, 256, 245, 247,
923  247, 254, 247, 248, 247, 247, 247, 247, 247, 247,
924  247, 247, 247, 249, 246, 249, 249, 241, 249, 250,
925 
926  235, 233, 232, 229, 250, 250, 228, 250, 250, 250,
927  250, 250, 250, 253, 226, 225, 253, 223, 199, 198,
928  194, 193, 253, 253, 191, 253, 255, 255, 495, 255,
929  255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
930  260, 260, 154, 260, 260, 260, 260, 260, 260, 260,
931  260, 260, 260, 260, 261, 154, 261, 261, 49, 261,
932  264, 264, 49, 264, 264, 49, 264, 270, 49, 495,
933  495, 495, 270, 270, 270, 270, 270, 270, 270, 270,
934  270, 272, 495, 495, 495, 495, 495, 272, 272, 495,
935  272, 274, 274, 495, 274, 495, 274, 274, 274, 274,
936 
937  274, 274, 274, 274, 274, 280, 280, 495, 280, 280,
938  280, 280, 280, 280, 280, 280, 280, 280, 280, 287,
939  495, 287, 287, 495, 287, 295, 495, 295, 295, 495,
940  295, 296, 296, 495, 495, 296, 296, 296, 296, 296,
941  296, 296, 296, 495, 296, 298, 298, 298, 298, 298,
942  298, 298, 298, 298, 298, 298, 298, 298, 298, 301,
943  301, 495, 495, 301, 301, 301, 301, 301, 301, 301,
944  301, 495, 301, 303, 303, 303, 303, 303, 303, 303,
945  303, 303, 303, 303, 303, 303, 303, 306, 306, 306,
946  495, 306, 306, 306, 306, 306, 306, 306, 306, 306,
947 
948  306, 313, 495, 495, 495, 495, 495, 313, 313, 495,
949  313, 313, 495, 313, 318, 495, 495, 495, 495, 318,
950  495, 318, 495, 318, 318, 495, 318, 322, 495, 495,
951  495, 495, 495, 322, 322, 495, 322, 322, 495, 322,
952  323, 495, 495, 495, 323, 323, 495, 323, 323, 323,
953  323, 495, 323, 325, 325, 495, 325, 325, 325, 325,
954  325, 325, 325, 325, 325, 325, 325, 326, 326, 495,
955  326, 326, 326, 326, 326, 326, 326, 326, 326, 326,
956  326, 327, 327, 327, 327, 495, 327, 327, 327, 327,
957  327, 327, 327, 327, 327, 332, 495, 495, 495, 495,
958 
959  495, 495, 495, 495, 332, 332, 495, 332, 203, 495,
960  495, 495, 203, 203, 495, 203, 203, 203, 203, 495,
961  203, 333, 333, 333, 333, 333, 333, 333, 333, 333,
962  495, 333, 333, 333, 333, 210, 495, 495, 495, 495,
963  495, 495, 495, 495, 210, 210, 495, 210, 338, 495,
964  495, 495, 338, 338, 495, 338, 338, 338, 338, 495,
965  338, 216, 495, 495, 495, 216, 216, 495, 216, 216,
966  216, 216, 495, 216, 343, 343, 343, 343, 343, 343,
967  343, 343, 343, 495, 343, 343, 343, 343, 222, 222,
968  495, 495, 495, 222, 222, 495, 222, 222, 495, 495,
969 
970  222, 222, 351, 351, 495, 351, 351, 351, 351, 351,
971  351, 351, 351, 351, 351, 351, 352, 352, 352, 352,
972  495, 352, 352, 352, 352, 352, 352, 352, 352, 352,
973  227, 495, 227, 227, 495, 227, 231, 495, 495, 495,
974  231, 231, 231, 231, 231, 231, 231, 231, 495, 231,
975  236, 236, 495, 236, 495, 236, 236, 236, 236, 236,
976  236, 236, 236, 236, 245, 495, 245, 245, 495, 245,
977  358, 358, 495, 358, 358, 358, 358, 358, 358, 358,
978  358, 358, 358, 358, 249, 495, 249, 249, 495, 249,
979  250, 495, 495, 495, 495, 250, 250, 495, 250, 250,
980 
981  250, 250, 250, 250, 253, 495, 495, 253, 495, 495,
982  495, 495, 495, 253, 253, 495, 253, 361, 495, 495,
983  495, 495, 495, 495, 361, 495, 361, 361, 495, 361,
984  255, 255, 495, 255, 255, 255, 255, 255, 255, 255,
985  255, 255, 255, 255, 363, 363, 363, 363, 363, 363,
986  363, 363, 363, 363, 363, 363, 363, 363, 366, 366,
987  495, 366, 366, 366, 366, 366, 366, 366, 366, 366,
988  366, 366, 261, 495, 261, 261, 495, 261, 367, 367,
989  495, 367, 264, 264, 495, 264, 264, 495, 264, 270,
990  495, 495, 495, 495, 270, 270, 270, 270, 270, 270,
991 
992  270, 270, 270, 372, 495, 495, 495, 495, 495, 495,
993  372, 495, 372, 372, 495, 372, 374, 374, 495, 374,
994  374, 374, 374, 374, 374, 374, 374, 374, 374, 374,
995  280, 280, 495, 280, 280, 280, 280, 280, 280, 280,
996  280, 280, 280, 280, 287, 495, 287, 287, 495, 287,
997  295, 495, 295, 295, 495, 295, 296, 296, 495, 495,
998  296, 296, 296, 296, 296, 296, 296, 296, 495, 296,
999  301, 301, 495, 495, 301, 301, 301, 301, 301, 301,
1000  301, 301, 495, 301, 306, 306, 306, 495, 306, 306,
1001  306, 306, 306, 306, 306, 306, 306, 306, 392, 495,
1002 
1003  495, 495, 495, 495, 495, 495, 495, 392, 392, 495,
1004  392, 313, 495, 495, 495, 495, 495, 313, 313, 495,
1005  313, 313, 495, 313, 318, 495, 495, 495, 495, 318,
1006  495, 318, 495, 318, 318, 495, 318, 396, 495, 495,
1007  495, 495, 495, 495, 495, 495, 396, 396, 495, 396,
1008  322, 495, 495, 495, 495, 495, 322, 322, 495, 322,
1009  322, 495, 322, 323, 495, 495, 495, 323, 323, 495,
1010  323, 323, 323, 323, 495, 323, 325, 325, 495, 325,
1011  325, 325, 325, 325, 325, 325, 325, 325, 325, 325,
1012  326, 326, 495, 326, 326, 326, 326, 326, 326, 326,
1013 
1014  326, 326, 326, 326, 332, 495, 495, 495, 495, 495,
1015  495, 495, 495, 332, 332, 495, 332, 400, 495, 495,
1016  495, 400, 400, 495, 400, 400, 400, 400, 495, 400,
1017  203, 495, 495, 495, 203, 203, 495, 203, 203, 203,
1018  203, 495, 203, 338, 495, 495, 495, 338, 338, 495,
1019  338, 338, 338, 338, 495, 338, 216, 495, 495, 495,
1020  216, 216, 495, 216, 216, 216, 216, 495, 216, 351,
1021  351, 495, 351, 351, 351, 351, 351, 351, 351, 351,
1022  351, 351, 351, 227, 227, 495, 227, 227, 495, 227,
1023  424, 424, 495, 424, 424, 495, 424, 427, 427, 427,
1024 
1025  427, 495, 427, 427, 427, 427, 427, 427, 427, 427,
1026  427, 441, 495, 495, 495, 495, 495, 441, 441, 495,
1027  441, 441, 495, 441, 443, 495, 495, 495, 495, 495,
1028  443, 443, 495, 443, 443, 495, 443, 456, 456, 495,
1029  456, 471, 495, 495, 495, 495, 495, 495, 471, 471,
1030  471, 471, 495, 471, 473, 473, 495, 473, 482, 495,
1031  495, 495, 495, 495, 495, 482, 482, 482, 482, 495,
1032  482, 47, 495, 495, 495, 495, 495, 495, 495, 495,
1033  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
1034  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
1035 
1036  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
1037  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
1038  495, 495, 495, 495
1039  } ;
1040 
1041 static yyconst flex_int16_t yy_chk[2725] =
1042  { 0,
1043  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1044  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1045  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1046  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1047  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1048  3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
1049  4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
1050  4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
1051  4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
1052  4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
1053 
1054  4, 4, 4, 4, 5, 5, 5, 5, 5, 5,
1055  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1056  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1057  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1058  5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
1059  5, 5, 5, 5, 5, 5, 9, 9, 493, 9,
1060  10, 10, 9, 10, 11, 492, 10, 11, 12, 12,
1061  17, 17, 12, 17, 17, 88, 17, 18, 18, 88,
1062  18, 18, 17, 18, 90, 54, 9, 54, 90, 18,
1063  10, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1064 
1065  13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1066  13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1067  13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1068  13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
1069  13, 13, 13, 15, 15, 15, 15, 15, 15, 15,
1070  15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
1071  15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
1072  15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
1073  15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
1074  15, 15, 15, 15, 15, 19, 106, 20, 110, 110,
1075 
1076  106, 19, 19, 20, 20, 19, 490, 20, 21, 21,
1077  21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
1078  21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
1079  21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
1080  21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
1081  21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
1082  23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
1083  23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
1084  23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
1085  23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
1086 
1087  23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
1088  23, 23, 25, 25, 25, 147, 25, 59, 147, 25,
1089  26, 26, 26, 256, 26, 59, 256, 26, 59, 27,
1090  27, 25, 27, 27, 59, 27, 489, 28, 28, 26,
1091  28, 28, 488, 28, 29, 29, 29, 29, 29, 29,
1092  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
1093  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
1094  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
1095  29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
1096  29, 29, 29, 29, 29, 29, 33, 33, 33, 33,
1097 
1098  33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
1099  33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
1100  33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
1101  33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
1102  33, 33, 33, 33, 33, 33, 33, 33, 35, 36,
1103  35, 36, 487, 35, 36, 37, 38, 37, 38, 92,
1104  37, 38, 39, 40, 39, 40, 92, 39, 40, 122,
1105  122, 65, 127, 127, 574, 92, 574, 35, 36, 65,
1106  134, 134, 65, 485, 37, 38, 165, 165, 65, 169,
1107  169, 39, 40, 41, 41, 41, 41, 41, 41, 41,
1108 
1109  41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
1110  41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
1111  41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
1112  41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
1113  41, 41, 41, 41, 41, 43, 43, 43, 43, 43,
1114  43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
1115  43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
1116  43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
1117  43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
1118  43, 43, 43, 43, 43, 43, 43, 45, 45, 45,
1119 
1120  45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1121  45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1122  45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1123  45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1124  45, 45, 45, 45, 45, 45, 45, 45, 45, 60,
1125  61, 62, 479, 64, 258, 258, 217, 60, 61, 62,
1126  60, 61, 62, 63, 67, 66, 60, 61, 62, 265,
1127  265, 63, 67, 66, 63, 67, 66, 269, 269, 179,
1128  63, 67, 66, 276, 276, 68, 61, 64, 64, 60,
1129  64, 179, 64, 68, 149, 62, 68, 149, 69, 217,
1130 
1131  67, 242, 68, 186, 63, 66, 69, 316, 242, 69,
1132  143, 143, 143, 143, 186, 69, 149, 242, 316, 180,
1133  151, 143, 143, 151, 190, 174, 344, 174, 237, 68,
1134  174, 180, 237, 239, 475, 149, 190, 239, 143, 69,
1135  79, 79, 151, 79, 292, 201, 79, 292, 79, 79,
1136  79, 79, 79, 201, 79, 79, 79, 79, 79, 79,
1137  180, 151, 201, 467, 251, 192, 200, 203, 251, 344,
1138  79, 79, 79, 192, 200, 203, 192, 200, 203, 282,
1139  282, 282, 192, 200, 203, 299, 299, 461, 205, 206,
1140  79, 79, 142, 142, 142, 142, 205, 206, 209, 205,
1141 
1142  206, 207, 208, 142, 142, 205, 206, 330, 142, 207,
1143  208, 311, 207, 208, 210, 304, 304, 313, 207, 208,
1144  142, 205, 210, 311, 330, 210, 206, 386, 386, 313,
1145  211, 210, 209, 209, 307, 209, 307, 209, 211, 307,
1146  212, 211, 213, 207, 214, 208, 456, 211, 212, 318,
1147  213, 212, 214, 213, 215, 214, 216, 212, 218, 213,
1148  318, 214, 215, 456, 216, 215, 218, 216, 409, 218,
1149  211, 215, 219, 216, 452, 218, 212, 388, 388, 220,
1150  219, 314, 320, 219, 221, 214, 213, 220, 322, 219,
1151  220, 218, 221, 314, 320, 221, 220, 355, 444, 323,
1152 
1153  322, 221, 283, 283, 283, 283, 392, 323, 393, 219,
1154  323, 409, 435, 283, 283, 332, 323, 380, 392, 424,
1155  393, 220, 355, 332, 314, 419, 332, 221, 230, 230,
1156  283, 230, 332, 380, 230, 411, 230, 230, 230, 230,
1157  230, 410, 230, 230, 230, 230, 230, 230, 399, 396,
1158  393, 395, 284, 284, 284, 284, 394, 334, 230, 230,
1159  230, 396, 391, 284, 284, 334, 432, 390, 334, 432,
1160  432, 432, 389, 335, 334, 336, 384, 337, 230, 230,
1161  284, 335, 470, 336, 335, 337, 336, 338, 337, 339,
1162  335, 383, 336, 441, 337, 338, 443, 339, 338, 470,
1163 
1164  339, 340, 334, 341, 338, 441, 339, 382, 443, 340,
1165  471, 341, 340, 342, 341, 346, 336, 347, 340, 337,
1166  341, 342, 339, 346, 342, 347, 346, 471, 347, 348,
1167  342, 349, 346, 400, 347, 381, 377, 348, 340, 349,
1168  348, 400, 349, 376, 400, 341, 348, 473, 349, 375,
1169  400, 378, 378, 378, 401, 402, 342, 373, 378, 372,
1170  346, 378, 401, 402, 473, 401, 402, 403, 404, 405,
1171  348, 401, 402, 349, 378, 403, 404, 405, 403, 404,
1172  405, 406, 371, 407, 403, 404, 405, 369, 368, 406,
1173  442, 407, 406, 408, 407, 458, 458, 458, 406, 401,
1174 
1175  407, 408, 442, 474, 408, 412, 484, 367, 481, 413,
1176  408, 460, 404, 412, 405, 474, 412, 413, 484, 414,
1177  413, 415, 412, 460, 407, 481, 413, 414, 365, 415,
1178  414, 445, 415, 362, 442, 408, 414, 361, 415, 445,
1179  360, 446, 445, 447, 482, 448, 357, 356, 445, 446,
1180  412, 447, 446, 448, 447, 449, 448, 460, 446, 450,
1181  447, 482, 448, 449, 354, 415, 449, 450, 353, 451,
1182  450, 453, 449, 350, 345, 331, 450, 451, 329, 453,
1183  451, 328, 453, 454, 455, 324, 451, 321, 453, 447,
1184  448, 454, 455, 319, 454, 455, 459, 459, 459, 462,
1185 
1186  454, 455, 317, 463, 464, 315, 459, 462, 312, 310,
1187  462, 463, 464, 451, 463, 464, 462, 465, 466, 309,
1188  463, 464, 308, 306, 302, 465, 466, 297, 465, 466,
1189  455, 468, 469, 476, 465, 466, 294, 293, 291, 468,
1190  469, 476, 468, 469, 476, 477, 478, 288, 468, 469,
1191  476, 281, 279, 477, 478, 278, 477, 478, 480, 486,
1192  275, 273, 477, 478, 466, 272, 480, 486, 271, 480,
1193  486, 268, 267, 264, 262, 480, 486, 496, 496, 496,
1194  496, 496, 496, 496, 496, 496, 496, 496, 496, 496,
1195  496, 497, 497, 497, 497, 497, 497, 497, 497, 497,
1196 
1197  497, 497, 497, 497, 497, 498, 498, 498, 498, 498,
1198  498, 498, 498, 498, 498, 498, 498, 498, 498, 499,
1199  499, 499, 499, 499, 499, 499, 499, 499, 499, 499,
1200  499, 499, 499, 500, 500, 500, 500, 500, 500, 500,
1201  500, 500, 500, 500, 500, 500, 500, 501, 501, 501,
1202  501, 501, 501, 501, 501, 501, 501, 501, 501, 501,
1203  501, 502, 502, 502, 502, 502, 502, 502, 502, 502,
1204  502, 502, 502, 502, 502, 503, 503, 503, 503, 503,
1205  503, 503, 503, 503, 503, 503, 503, 503, 503, 504,
1206  504, 504, 504, 504, 504, 504, 504, 504, 504, 504,
1207 
1208  504, 504, 504, 505, 505, 505, 505, 505, 505, 505,
1209  505, 505, 505, 505, 505, 505, 505, 506, 506, 506,
1210  506, 506, 506, 506, 506, 506, 506, 506, 506, 506,
1211  506, 507, 257, 254, 253, 252, 248, 246, 241, 240,
1212  507, 507, 235, 507, 508, 508, 233, 508, 508, 508,
1213  508, 508, 508, 508, 508, 508, 508, 508, 509, 232,
1214  229, 228, 509, 509, 226, 509, 509, 509, 509, 223,
1215  509, 510, 202, 199, 198, 194, 193, 191, 188, 182,
1216  510, 510, 176, 510, 511, 173, 172, 171, 511, 511,
1217  170, 511, 511, 511, 511, 168, 511, 512, 512, 163,
1218 
1219  158, 157, 512, 512, 148, 512, 512, 146, 140, 512,
1220  512, 513, 513, 138, 513, 513, 513, 513, 513, 513,
1221  513, 513, 513, 513, 513, 514, 136, 514, 514, 133,
1222  514, 515, 131, 130, 126, 515, 515, 515, 515, 515,
1223  515, 515, 515, 125, 515, 516, 516, 121, 516, 516,
1224  516, 516, 516, 516, 516, 516, 516, 516, 516, 517,
1225  517, 118, 517, 111, 517, 517, 517, 517, 517, 517,
1226  517, 517, 517, 518, 109, 518, 518, 108, 518, 519,
1227  519, 107, 519, 101, 519, 519, 519, 519, 519, 519,
1228  519, 519, 519, 520, 97, 520, 520, 91, 520, 521,
1229 
1230  86, 84, 83, 78, 521, 521, 77, 521, 521, 521,
1231  521, 521, 521, 522, 74, 73, 522, 72, 58, 55,
1232  53, 52, 522, 522, 51, 522, 523, 523, 47, 523,
1233  523, 523, 523, 523, 523, 523, 523, 523, 523, 523,
1234  524, 524, 32, 524, 524, 524, 524, 524, 524, 524,
1235  524, 524, 524, 524, 525, 31, 525, 525, 8, 525,
1236  526, 526, 7, 526, 526, 2, 526, 527, 1, 0,
1237  0, 0, 527, 527, 527, 527, 527, 527, 527, 527,
1238  527, 528, 0, 0, 0, 0, 0, 528, 528, 0,
1239  528, 529, 529, 0, 529, 0, 529, 529, 529, 529,
1240 
1241  529, 529, 529, 529, 529, 530, 530, 0, 530, 530,
1242  530, 530, 530, 530, 530, 530, 530, 530, 530, 531,
1243  0, 531, 531, 0, 531, 532, 0, 532, 532, 0,
1244  532, 533, 533, 0, 0, 533, 533, 533, 533, 533,
1245  533, 533, 533, 0, 533, 534, 534, 534, 534, 534,
1246  534, 534, 534, 534, 534, 534, 534, 534, 534, 535,
1247  535, 0, 0, 535, 535, 535, 535, 535, 535, 535,
1248  535, 0, 535, 536, 536, 536, 536, 536, 536, 536,
1249  536, 536, 536, 536, 536, 536, 536, 537, 537, 537,
1250  0, 537, 537, 537, 537, 537, 537, 537, 537, 537,
1251 
1252  537, 538, 0, 0, 0, 0, 0, 538, 538, 0,
1253  538, 538, 0, 538, 539, 0, 0, 0, 0, 539,
1254  0, 539, 0, 539, 539, 0, 539, 540, 0, 0,
1255  0, 0, 0, 540, 540, 0, 540, 540, 0, 540,
1256  541, 0, 0, 0, 541, 541, 0, 541, 541, 541,
1257  541, 0, 541, 542, 542, 0, 542, 542, 542, 542,
1258  542, 542, 542, 542, 542, 542, 542, 543, 543, 0,
1259  543, 543, 543, 543, 543, 543, 543, 543, 543, 543,
1260  543, 544, 544, 544, 544, 0, 544, 544, 544, 544,
1261  544, 544, 544, 544, 544, 545, 0, 0, 0, 0,
1262 
1263  0, 0, 0, 0, 545, 545, 0, 545, 546, 0,
1264  0, 0, 546, 546, 0, 546, 546, 546, 546, 0,
1265  546, 547, 547, 547, 547, 547, 547, 547, 547, 547,
1266  0, 547, 547, 547, 547, 548, 0, 0, 0, 0,
1267  0, 0, 0, 0, 548, 548, 0, 548, 549, 0,
1268  0, 0, 549, 549, 0, 549, 549, 549, 549, 0,
1269  549, 550, 0, 0, 0, 550, 550, 0, 550, 550,
1270  550, 550, 0, 550, 551, 551, 551, 551, 551, 551,
1271  551, 551, 551, 0, 551, 551, 551, 551, 552, 552,
1272  0, 0, 0, 552, 552, 0, 552, 552, 0, 0,
1273 
1274  552, 552, 553, 553, 0, 553, 553, 553, 553, 553,
1275  553, 553, 553, 553, 553, 553, 554, 554, 554, 554,
1276  0, 554, 554, 554, 554, 554, 554, 554, 554, 554,
1277  555, 0, 555, 555, 0, 555, 556, 0, 0, 0,
1278  556, 556, 556, 556, 556, 556, 556, 556, 0, 556,
1279  557, 557, 0, 557, 0, 557, 557, 557, 557, 557,
1280  557, 557, 557, 557, 558, 0, 558, 558, 0, 558,
1281  559, 559, 0, 559, 559, 559, 559, 559, 559, 559,
1282  559, 559, 559, 559, 560, 0, 560, 560, 0, 560,
1283  561, 0, 0, 0, 0, 561, 561, 0, 561, 561,
1284 
1285  561, 561, 561, 561, 562, 0, 0, 562, 0, 0,
1286  0, 0, 0, 562, 562, 0, 562, 563, 0, 0,
1287  0, 0, 0, 0, 563, 0, 563, 563, 0, 563,
1288  564, 564, 0, 564, 564, 564, 564, 564, 564, 564,
1289  564, 564, 564, 564, 565, 565, 565, 565, 565, 565,
1290  565, 565, 565, 565, 565, 565, 565, 565, 566, 566,
1291  0, 566, 566, 566, 566, 566, 566, 566, 566, 566,
1292  566, 566, 567, 0, 567, 567, 0, 567, 568, 568,
1293  0, 568, 569, 569, 0, 569, 569, 0, 569, 570,
1294  0, 0, 0, 0, 570, 570, 570, 570, 570, 570,
1295 
1296  570, 570, 570, 571, 0, 0, 0, 0, 0, 0,
1297  571, 0, 571, 571, 0, 571, 572, 572, 0, 572,
1298  572, 572, 572, 572, 572, 572, 572, 572, 572, 572,
1299  573, 573, 0, 573, 573, 573, 573, 573, 573, 573,
1300  573, 573, 573, 573, 575, 0, 575, 575, 0, 575,
1301  576, 0, 576, 576, 0, 576, 577, 577, 0, 0,
1302  577, 577, 577, 577, 577, 577, 577, 577, 0, 577,
1303  578, 578, 0, 0, 578, 578, 578, 578, 578, 578,
1304  578, 578, 0, 578, 579, 579, 579, 0, 579, 579,
1305  579, 579, 579, 579, 579, 579, 579, 579, 580, 0,
1306 
1307  0, 0, 0, 0, 0, 0, 0, 580, 580, 0,
1308  580, 581, 0, 0, 0, 0, 0, 581, 581, 0,
1309  581, 581, 0, 581, 582, 0, 0, 0, 0, 582,
1310  0, 582, 0, 582, 582, 0, 582, 583, 0, 0,
1311  0, 0, 0, 0, 0, 0, 583, 583, 0, 583,
1312  584, 0, 0, 0, 0, 0, 584, 584, 0, 584,
1313  584, 0, 584, 585, 0, 0, 0, 585, 585, 0,
1314  585, 585, 585, 585, 0, 585, 586, 586, 0, 586,
1315  586, 586, 586, 586, 586, 586, 586, 586, 586, 586,
1316  587, 587, 0, 587, 587, 587, 587, 587, 587, 587,
1317 
1318  587, 587, 587, 587, 588, 0, 0, 0, 0, 0,
1319  0, 0, 0, 588, 588, 0, 588, 589, 0, 0,
1320  0, 589, 589, 0, 589, 589, 589, 589, 0, 589,
1321  590, 0, 0, 0, 590, 590, 0, 590, 590, 590,
1322  590, 0, 590, 591, 0, 0, 0, 591, 591, 0,
1323  591, 591, 591, 591, 0, 591, 592, 0, 0, 0,
1324  592, 592, 0, 592, 592, 592, 592, 0, 592, 593,
1325  593, 0, 593, 593, 593, 593, 593, 593, 593, 593,
1326  593, 593, 593, 594, 594, 0, 594, 594, 0, 594,
1327  595, 595, 0, 595, 595, 0, 595, 596, 596, 596,
1328 
1329  596, 0, 596, 596, 596, 596, 596, 596, 596, 596,
1330  596, 597, 0, 0, 0, 0, 0, 597, 597, 0,
1331  597, 597, 0, 597, 598, 0, 0, 0, 0, 0,
1332  598, 598, 0, 598, 598, 0, 598, 599, 599, 0,
1333  599, 600, 0, 0, 0, 0, 0, 0, 600, 600,
1334  600, 600, 0, 600, 601, 601, 0, 601, 602, 0,
1335  0, 0, 0, 0, 0, 602, 602, 602, 602, 0,
1336  602, 495, 495, 495, 495, 495, 495, 495, 495, 495,
1337  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
1338  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
1339 
1340  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
1341  495, 495, 495, 495, 495, 495, 495, 495, 495, 495,
1342  495, 495, 495, 495
1343  } ;
1344 
1345 extern int pyscannerYY_flex_debug;
1346 int pyscannerYY_flex_debug = 0;
1347 
1348 static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;
1349 static char *yy_full_match;
1350 static int yy_lp;
1351 static int yy_looking_for_trail_begin = 0;
1352 static int yy_full_lp;
1353 static int *yy_full_state;
1354 #define YY_TRAILING_MASK 0x2000
1355 #define YY_TRAILING_HEAD_MASK 0x4000
1356 #define REJECT \
1357 { \
1358 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscannerYYtext */ \
1359 yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
1360 (yy_lp) = (yy_full_lp); /* restore orig. accepting pos. */ \
1361 (yy_state_ptr) = (yy_full_state); /* restore orig. state */ \
1362 yy_current_state = *(yy_state_ptr); /* restore curr. state */ \
1363 ++(yy_lp); \
1364 goto find_rule; \
1365 }
1366 
1367 #define yymore() yymore_used_but_not_detected
1368 #define YY_MORE_ADJ 0
1369 #define YY_RESTORE_YY_MORE_OFFSET
1370 char *pyscannerYYtext;
1371 #line 1 "pyscanner.l"
1372 /******************************************************************************
1373  *
1374  *
1375  *
1376  * Copyright (C) 1997-2015 by Dimitri van Heesch.
1377  *
1378  * Permission to use, copy, modify, and distribute this software and its
1379  * documentation under the terms of the GNU General Public License is hereby
1380  * granted. No representations are made about the suitability of this software
1381  * for any purpose. It is provided "as is" without express or implied warranty.
1382  * See the GNU General Public License for more details.
1383  *
1384  * Documents produced by Doxygen are derivative works derived from the
1385  * input used in their production; they are not affected by this license.
1386  *
1387  */
1388 /* This code is based on the work done by the MoxyPyDoxy team
1389  * (Linda Leong, Mike Rivera, Kim Truong, and Gabriel Estrada)
1390  * in Spring 2005 as part of CS 179E: Compiler Design Project
1391  * at the University of California, Riverside; the course was
1392  * taught by Peter H. Froehlich <phf@acm.org>.
1393  */
1394 #line 26 "pyscanner.l"
1395 
1396 /*
1397  * includes
1398  */
1399 #include <stdio.h>
1400 #include <stdlib.h>
1401 #include <assert.h>
1402 #include <ctype.h>
1403 
1404 #include <qarray.h>
1405 #include <qstack.h>
1406 #include <qregexp.h>
1407 #include <qfile.h>
1408 #include <qfileinfo.h>
1409 
1410 #include "pyscanner.h"
1411 #include "entry.h"
1412 #include "message.h"
1413 #include "config.h"
1414 #include "doxygen.h"
1415 #include "util.h"
1416 #include "defargs.h"
1417 #include "language.h"
1418 #include "commentscan.h"
1419 #include "pycode.h"
1420 #include "arguments.h"
1421 
1422 // Toggle for some debugging info
1423 //#define DBG_CTX(x) fprintf x
1424 #define DBG_CTX(x) do { } while(0)
1425 
1426 #define YY_NO_INPUT 1
1427 #define YY_NO_UNISTD_H 1
1428 
1429 /* -----------------------------------------------------------------
1430  *
1431  * statics
1432  */
1433 
1434 
1435 static ParserInterface *g_thisParser;
1436 static const char * inputString;
1437 static int inputPosition;
1438 static QFile inputFile;
1439 
1440 static Protection protection;
1441 
1442 static Entry* current_root = 0 ;
1443 static Entry* current = 0 ;
1444 static Entry* previous = 0 ;
1445 static Entry* bodyEntry = 0 ;
1446 static int yyLineNr = 1 ;
1447 static QCString yyFileName;
1448 static MethodTypes mtype;
1449 static bool gstat;
1450 static Specifier virt;
1451 
1452 static int docBlockContext;
1453 static QCString docBlock;
1454 static bool docBlockInBody;
1455 static bool docBlockJavaStyle;
1456 static bool docBrief;
1457 static bool docBlockSpecial;
1458 
1459 static bool g_doubleQuote;
1460 static bool g_specialBlock;
1461 static int g_stringContext;
1462 static QGString * g_copyString;
1463 static int g_indent = 0;
1464 static int g_curIndent = 0;
1465 
1466 static QDict<QCString> g_packageNameCache(257);
1467 
1468 static char g_atomStart;
1469 static char g_atomEnd;
1470 static int g_atomCount;
1471 
1472 //static bool g_insideConstructor;
1473 
1474 static QCString g_moduleScope;
1475 static QCString g_packageName;
1476 
1477 //static bool g_hideClassDocs;
1478 
1479 static QCString g_defVal;
1480 static int g_braceCount;
1481 
1482 static bool g_lexInit = FALSE;
1483 static bool g_packageCommentAllowed;
1484 
1485 static bool g_start_init = FALSE;
1486 static int g_search_count = 0;
1487 
1488 //-----------------------------------------------------------------------------
1489 
1490 
1491 static void initParser()
1492 {
1493  protection = Public;
1494  mtype = Method;
1495  gstat = FALSE;
1496  virt = Normal;
1497  previous = 0;
1498  g_packageCommentAllowed = TRUE;
1499  g_packageNameCache.setAutoDelete(TRUE);
1500 }
1501 
1502 static void initEntry()
1503 {
1504  //current->python = TRUE;
1505  current->protection = protection ;
1506  current->mtype = mtype;
1507  current->virt = virt;
1508  current->stat = gstat;
1509  current->lang = SrcLangExt_Python;
1510  current->setParent(current_root);
1511  initGroupInfo(current);
1512  gstat = FALSE;
1513 }
1514 
1515 static void newEntry()
1516 {
1517  previous = current;
1518  current_root->addSubEntry(current);
1519  current = new Entry ;
1520  initEntry();
1521 }
1522 
1523 static void newVariable()
1524 {
1525  if (!current->name.isEmpty() && current->name.at(0)=='_') // mark as private
1526  {
1527  current->protection=Private;
1528  }
1529  if (current_root->section&Entry::COMPOUND_MASK) // mark as class variable
1530  {
1531  current->stat = TRUE;
1532  }
1533  newEntry();
1534 }
1535 
1536 static void newFunction()
1537 {
1538  if (current->name.left(2)=="__" && current->name.right(2)=="__")
1539  {
1540  // special method name, see
1541  // http://docs.python.org/ref/specialnames.html
1542  current->protection=Public;
1543  }
1544  else if (current->name.at(0)=='_')
1545  {
1546  current->protection=Private;
1547  }
1548 }
1549 
1550 static inline int computeIndent(const char *s)
1551 {
1552  int col=0;
1553  static int tabSize=Config_getInt("TAB_SIZE");
1554  const char *p=s;
1555  char c;
1556  while ((c=*p++))
1557  {
1558  if (c==' ') col++;
1559  else if (c=='\t') col+=tabSize-(col%tabSize);
1560  else break;
1561  }
1562  return col;
1563 }
1564 
1565 static QCString findPackageScopeFromPath(const QCString &path)
1566 {
1567  QCString *pScope = g_packageNameCache.find(path);
1568  if (pScope)
1569  {
1570  return *pScope;
1571  }
1572  QFileInfo pf(path+"/__init__.py"); // found package initialization file
1573  if (pf.exists())
1574  {
1575  int i=path.findRev('/');
1576  if (i!=-1)
1577  {
1578  QCString scope = findPackageScopeFromPath(path.left(i));
1579  if (!scope.isEmpty())
1580  {
1581  scope+="::";
1582  }
1583  scope+=path.mid(i+1);
1584  g_packageNameCache.insert(path,new QCString(scope));
1585  return scope;
1586  }
1587  }
1588  return "";
1589 }
1590 
1591 static QCString findPackageScope(const char *fileName)
1592 {
1593  if (fileName==0) return "";
1594  QFileInfo fi(fileName);
1595  return findPackageScopeFromPath(fi.dirPath(TRUE).data());
1596 }
1597 
1598 //-----------------------------------------------------------------------------
1599 
1600 static void lineCount()
1601 {
1602  DBG_CTX((stderr,"yyLineNr=%d\n",yyLineNr));
1603  for (const char *p = pyscannerYYtext; *p; ++p)
1604  {
1605  yyLineNr += (*p == '\n') ;
1606  }
1607 }
1608 
1609 static void incLineNr()
1610 {
1611  DBG_CTX((stderr,"yyLineNr=%d\n",yyLineNr));
1612  yyLineNr++;
1613 }
1614 
1615 #if 0
1616 // Appends the current-name to current-type;
1617 // Destroys current-name.
1618 // Destroys current->args and current->argList
1619 static void addType( Entry* current )
1620 {
1621  uint tl=current->type.length();
1622  if ( tl>0 && !current->name.isEmpty() && current->type.at(tl-1)!='.')
1623  {
1624  current->type += ' ' ;
1625  }
1626  current->type += current->name ;
1627  current->name.resize(0) ;
1628  tl=current->type.length();
1629  if ( tl>0 && !current->args.isEmpty() && current->type.at(tl-1)!='.')
1630  {
1631  current->type += ' ' ;
1632  }
1633  current->type += current->args ;
1634  current->args.resize(0) ;
1635  current->argList->clear();
1636 }
1637 
1638 static QCString stripQuotes(const char *s)
1639 {
1640  QCString name;
1641  if (s==0 || *s==0) return name;
1642  name=s;
1643  if (name.at(0)=='"' && name.at(name.length()-1)=='"')
1644  {
1645  name=name.mid(1,name.length()-2);
1646  }
1647  return name;
1648 }
1649 #endif
1650 //-----------------------------------------------------------------
1651 
1652 //-----------------------------------------------------------------
1653 static void startCommentBlock(bool brief)
1654 {
1655  if (brief)
1656  {
1657  current->briefFile = yyFileName;
1658  current->briefLine = yyLineNr;
1659  }
1660  else
1661  {
1662  current->docFile = yyFileName;
1663  current->docLine = yyLineNr;
1664  }
1665 }
1666 
1667 /*
1668 static void appendDocBlock() {
1669  previous = current;
1670  current_root->addSubEntry(current);
1671  current = new Entry;
1672  initEntry();
1673 }
1674 */
1675 
1676 static void handleCommentBlock(const QCString &doc,bool brief)
1677 {
1678  //printf("handleCommentBlock(doc=[%s] brief=%d docBlockInBody=%d docBlockJavaStyle=%d\n",
1679  // doc.data(),brief,docBlockInBody,docBlockJavaStyle);
1680 
1681  // TODO: Fix me
1682  docBlockInBody=FALSE;
1683 
1684  if (docBlockInBody && previous && !previous->doc.isEmpty())
1685  {
1686  previous->doc=previous->doc.stripWhiteSpace()+"\n\n";
1687  }
1688 
1689  int position = 0;
1690  bool needsEntry;
1691  int lineNr = brief ? current->briefLine : current->docLine;
1692  while (parseCommentBlock(
1693  g_thisParser,
1694  (docBlockInBody && previous) ? previous : current,
1695  doc, // text
1696  yyFileName, // file
1697  lineNr,
1698  docBlockInBody ? FALSE : brief,
1699  docBlockJavaStyle, // javadoc style // or FALSE,
1700  docBlockInBody,
1701  protection,
1702  position,
1703  needsEntry)
1704  ) // need to start a new entry
1705  {
1706  if (needsEntry)
1707  {
1708  newEntry();
1709  }
1710  }
1711  if (needsEntry)
1712  {
1713  newEntry();
1714  }
1715 
1716 }
1717 
1718 static void endOfDef(int correction=0)
1719 {
1720  //printf("endOfDef at=%d\n",yyLineNr);
1721  if (bodyEntry)
1722  {
1723  bodyEntry->endBodyLine = yyLineNr-correction;
1724  bodyEntry = 0;
1725  }
1726  newEntry();
1727  //g_insideConstructor = FALSE;
1728 }
1729 
1730 static inline void addToString(const char *s)
1731 {
1732  if (g_copyString) (*g_copyString)+=s;
1733 }
1734 
1735 static void initTriDoubleQuoteBlock()
1736 {
1737  docBlockContext = YY_START;
1738  docBlockInBody = FALSE;
1739  docBlockJavaStyle = TRUE;
1740  docBlockSpecial = pyscannerYYtext[3]=='!';
1741  docBlock.resize(0);
1742  g_doubleQuote = TRUE;
1743  startCommentBlock(FALSE);
1744 }
1745 
1746 static void initTriSingleQuoteBlock()
1747 {
1748  docBlockContext = YY_START;
1749  docBlockInBody = FALSE;
1750  docBlockJavaStyle = TRUE;
1751  docBlockSpecial = pyscannerYYtext[3]=='!';
1752  docBlock.resize(0);
1753  g_doubleQuote = FALSE;
1754  startCommentBlock(FALSE);
1755 }
1756 
1757 static void initSpecialBlock()
1758 {
1759  docBlockContext = YY_START;
1760  docBlockInBody = FALSE;
1761  docBlockJavaStyle = TRUE;
1762  docBrief = TRUE;
1763  docBlock.resize(0);
1764  startCommentBlock(TRUE);
1765 }
1766 
1767 static void searchFoundDef()
1768 {
1769  current->fileName = yyFileName;
1770  current->startLine = yyLineNr;
1771  current->bodyLine = yyLineNr;
1772  current->section = Entry::FUNCTION_SEC;
1773  current->lang = SrcLangExt_Python;
1774  current->virt = Normal;
1775  current->stat = gstat;
1776  current->mtype = mtype = Method;
1777  current->type.resize(0);
1778  current->name.resize(0);
1779  current->args.resize(0);
1780  current->argList->clear();
1781  g_packageCommentAllowed = FALSE;
1782  gstat=FALSE;
1783  //printf("searchFoundDef at=%d\n",yyLineNr);
1784 }
1785 
1786 static void searchFoundClass()
1787 {
1788  current->section = Entry::CLASS_SEC;
1789  current->argList->clear();
1790  current->type += "class" ;
1791  current->fileName = yyFileName;
1792  current->startLine = yyLineNr;
1793  current->bodyLine = yyLineNr;
1794  g_packageCommentAllowed = FALSE;
1795 }
1796 
1797 //-----------------------------------------------------------------------------
1798 /* ----------------------------------------------------------------- */
1799 #undef YY_INPUT
1800 #define YY_INPUT(buf,result,max_size) result=yyread(buf,max_size);
1801 
1802 static int yyread(char *buf,int max_size)
1803 {
1804  int c=0;
1805  while ( c < max_size && inputString[inputPosition] )
1806  {
1807  *buf = inputString[inputPosition++] ;
1808  //printf("%d (%c)\n",*buf,*buf);
1809  c++; buf++;
1810  }
1811  return c;
1812 }
1813 
1814 /* start command character */
1815 /* Main start state */
1816 
1817 
1818 /* Mid-comment states */
1819 /* %x FuncDoubleComment */
1820 /* %x ClassDoubleComment */
1821 
1822 
1823 
1824 /* Function states */
1825 
1826 
1827 
1828 
1829 /* Class states */
1830 
1831 
1832 
1833 
1834 /* Variable states */
1835 
1836 
1837 
1838 /* String states */
1839 
1840 
1841 
1842 /* import */
1843 
1844 
1845 
1846 #line 1847 "/nova/app/home/novasoft/doxygen/doxygen-1.8.11/build/generated_src/pyscanner.cpp"
1847 
1848 #define INITIAL 0
1849 #define Search 1
1850 #define SearchMemVars 2
1851 #define TryClassDocString 3
1852 #define TripleComment 4
1853 #define SpecialComment 5
1854 #define FunctionDec 6
1855 #define FunctionParams 7
1856 #define FunctionBody 8
1857 #define FunctionParamDefVal 9
1858 #define ClassDec 10
1859 #define ClassInheritance 11
1860 #define ClassCaptureIndent 12
1861 #define ClassBody 13
1862 #define VariableDec 14
1863 #define VariableEnd 15
1864 #define VariableAtom 16
1865 #define SingleQuoteString 17
1866 #define DoubleQuoteString 18
1867 #define TripleString 19
1868 #define FromMod 20
1869 #define FromModItem 21
1870 #define Import 22
1871 
1872 #ifndef YY_NO_UNISTD_H
1873 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1874  * down here because we want the user's section 1 to have been scanned first.
1875  * The user has a chance to override it with an option.
1876  */
1877 #include <unistd.h>
1878 #endif
1879 
1880 #ifndef YY_EXTRA_TYPE
1881 #define YY_EXTRA_TYPE void *
1882 #endif
1883 
1884 static int yy_init_globals (void );
1885 
1886 /* Accessor methods to globals.
1887  These are made visible to non-reentrant scanners for convenience. */
1888 
1889 int pyscannerYYlex_destroy (void );
1890 
1891 int pyscannerYYget_debug (void );
1892 
1893 void pyscannerYYset_debug (int debug_flag );
1894 
1895 YY_EXTRA_TYPE pyscannerYYget_extra (void );
1896 
1897 void pyscannerYYset_extra (YY_EXTRA_TYPE user_defined );
1898 
1899 FILE *pyscannerYYget_in (void );
1900 
1901 void pyscannerYYset_in (FILE * in_str );
1902 
1903 FILE *pyscannerYYget_out (void );
1904 
1905 void pyscannerYYset_out (FILE * out_str );
1906 
1907 int pyscannerYYget_leng (void );
1908 
1909 char *pyscannerYYget_text (void );
1910 
1911 int pyscannerYYget_lineno (void );
1912 
1913 void pyscannerYYset_lineno (int line_number );
1914 
1915 /* Macros after this point can all be overridden by user definitions in
1916  * section 1.
1917  */
1918 
1919 #ifndef YY_SKIP_YYWRAP
1920 #ifdef __cplusplus
1921 extern "C" int pyscannerYYwrap (void );
1922 #else
1923 extern int pyscannerYYwrap (void );
1924 #endif
1925 #endif
1926 
1927  static void yyunput (int c,char *buf_ptr );
1928 
1929 #ifndef yytext_ptr
1930 static void yy_flex_strncpy (char *,yyconst char *,int );
1931 #endif
1932 
1933 #ifdef YY_NEED_STRLEN
1934 static int yy_flex_strlen (yyconst char * );
1935 #endif
1936 
1937 #ifndef YY_NO_INPUT
1938 
1939 #ifdef __cplusplus
1940 static int yyinput (void );
1941 #else
1942 static int input (void );
1943 #endif
1944 
1945 #endif
1946 
1947 /* Amount of stuff to slurp up with each read. */
1948 #ifndef YY_READ_BUF_SIZE
1949 #define YY_READ_BUF_SIZE 8192
1950 #endif
1951 
1952 /* Copy whatever the last rule matched to the standard output. */
1953 #ifndef ECHO
1954 /* This used to be an fputs(), but since the string might contain NUL's,
1955  * we now use fwrite().
1956  */
1957 #define ECHO do { if (fwrite( pyscannerYYtext, pyscannerYYleng, 1, pyscannerYYout )) {} } while (0)
1958 #endif
1959 
1960 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1961  * is returned in "result".
1962  */
1963 #ifndef YY_INPUT
1964 #define YY_INPUT(buf,result,max_size) \
1965  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1966  { \
1967  int c = '*'; \
1968  unsigned n; \
1969  for ( n = 0; n < max_size && \
1970  (c = getc( pyscannerYYin )) != EOF && c != '\n'; ++n ) \
1971  buf[n] = (char) c; \
1972  if ( c == '\n' ) \
1973  buf[n++] = (char) c; \
1974  if ( c == EOF && ferror( pyscannerYYin ) ) \
1975  YY_FATAL_ERROR( "input in flex scanner failed" ); \
1976  result = n; \
1977  } \
1978  else \
1979  { \
1980  errno=0; \
1981  while ( (result = fread(buf, 1, max_size, pyscannerYYin))==0 && ferror(pyscannerYYin)) \
1982  { \
1983  if( errno != EINTR) \
1984  { \
1985  YY_FATAL_ERROR( "input in flex scanner failed" ); \
1986  break; \
1987  } \
1988  errno=0; \
1989  clearerr(pyscannerYYin); \
1990  } \
1991  }\
1992 \
1993 
1994 #endif
1995 
1996 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1997  * we don't want an extra ';' after the "return" because that will cause
1998  * some compilers to complain about unreachable statements.
1999  */
2000 #ifndef yyterminate
2001 #define yyterminate() return YY_NULL
2002 #endif
2003 
2004 /* Number of entries by which start-condition stack grows. */
2005 #ifndef YY_START_STACK_INCR
2006 #define YY_START_STACK_INCR 25
2007 #endif
2008 
2009 /* Report a fatal error. */
2010 #ifndef YY_FATAL_ERROR
2011 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
2012 #endif
2013 
2014 /* end tables serialization structures and prototypes */
2015 
2016 /* Default declaration of generated scanner - a define so the user can
2017  * easily add parameters.
2018  */
2019 #ifndef YY_DECL
2020 #define YY_DECL_IS_OURS 1
2021 
2022 extern int pyscannerYYlex (void);
2023 
2024 #define YY_DECL int pyscannerYYlex (void)
2025 #endif /* !YY_DECL */
2026 
2027 /* Code executed at the beginning of each rule, after pyscannerYYtext and pyscannerYYleng
2028  * have been set up.
2029  */
2030 #ifndef YY_USER_ACTION
2031 #define YY_USER_ACTION
2032 #endif
2033 
2034 /* Code executed at the end of each rule. */
2035 #ifndef YY_BREAK
2036 #define YY_BREAK break;
2037 #endif
2038 
2039 #define YY_RULE_SETUP \
2040  if ( pyscannerYYleng > 0 ) \
2041  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
2042  (pyscannerYYtext[pyscannerYYleng - 1] == '\n'); \
2043  YY_USER_ACTION
2044 
2045 /** The main scanner function which does all the work.
2046  */
2047 YY_DECL
2048 {
2049  register yy_state_type yy_current_state;
2050  register char *yy_cp, *yy_bp;
2051  register int yy_act;
2052 
2053 #line 538 "pyscanner.l"
2054 
2055 
2056  /* ------------ Function recognition rules -------------- */
2057 
2058 #line 2059 "/nova/app/home/novasoft/doxygen/doxygen-1.8.11/build/generated_src/pyscanner.cpp"
2059 
2060  if ( !(yy_init) )
2061  {
2062  (yy_init) = 1;
2063 
2064 #ifdef YY_USER_INIT
2065  YY_USER_INIT;
2066 #endif
2067 
2068  /* Create the reject buffer large enough to save one state per allowed character. */
2069  if ( ! (yy_state_buf) )
2070  (yy_state_buf) = (yy_state_type *)pyscannerYYalloc(YY_STATE_BUF_SIZE );
2071  if ( ! (yy_state_buf) )
2072  YY_FATAL_ERROR( "out of dynamic memory in pyscannerYYlex()" );
2073 
2074  if ( ! (yy_start) )
2075  (yy_start) = 1; /* first start state */
2076 
2077  if ( ! pyscannerYYin )
2078  pyscannerYYin = stdin;
2079 
2080  if ( ! pyscannerYYout )
2081  pyscannerYYout = stdout;
2082 
2083  if ( ! YY_CURRENT_BUFFER ) {
2084  pyscannerYYensure_buffer_stack ();
2085  YY_CURRENT_BUFFER_LVALUE =
2086  pyscannerYY_create_buffer(pyscannerYYin,YY_BUF_SIZE );
2087  }
2088 
2089  pyscannerYY_load_buffer_state( );
2090  }
2091 
2092  while ( 1 ) /* loops until end-of-file is reached */
2093  {
2094  yy_cp = (yy_c_buf_p);
2095 
2096  /* Support of pyscannerYYtext. */
2097  *yy_cp = (yy_hold_char);
2098 
2099  /* yy_bp points to the position in yy_ch_buf of the start of
2100  * the current run.
2101  */
2102  yy_bp = yy_cp;
2103 
2104  yy_current_state = (yy_start);
2105  yy_current_state += YY_AT_BOL();
2106 
2107  (yy_state_ptr) = (yy_state_buf);
2108  *(yy_state_ptr)++ = yy_current_state;
2109 
2110 yy_match:
2111  do
2112  {
2113  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
2114  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2115  {
2116  yy_current_state = (int) yy_def[yy_current_state];
2117  if ( yy_current_state >= 496 )
2118  yy_c = yy_meta[(unsigned int) yy_c];
2119  }
2120  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2121  *(yy_state_ptr)++ = yy_current_state;
2122  ++yy_cp;
2123  }
2124  while ( yy_current_state != 495 );
2125 
2126 yy_find_action:
2127  yy_current_state = *--(yy_state_ptr);
2128  (yy_lp) = yy_accept[yy_current_state];
2129 find_rule: /* we branch to this label when backing up */
2130  for ( ; ; ) /* until we find what rule we matched */
2131  {
2132  if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
2133  {
2134  yy_act = yy_acclist[(yy_lp)];
2135  if ( yy_act & YY_TRAILING_HEAD_MASK ||
2136  (yy_looking_for_trail_begin) )
2137  {
2138  if ( yy_act == (yy_looking_for_trail_begin) )
2139  {
2140  (yy_looking_for_trail_begin) = 0;
2141  yy_act &= ~YY_TRAILING_HEAD_MASK;
2142  break;
2143  }
2144  }
2145  else if ( yy_act & YY_TRAILING_MASK )
2146  {
2147  (yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;
2148  (yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;
2149  (yy_full_match) = yy_cp;
2150  (yy_full_state) = (yy_state_ptr);
2151  (yy_full_lp) = (yy_lp);
2152  }
2153  else
2154  {
2155  (yy_full_match) = yy_cp;
2156  (yy_full_state) = (yy_state_ptr);
2157  (yy_full_lp) = (yy_lp);
2158  break;
2159  }
2160  ++(yy_lp);
2161  goto find_rule;
2162  }
2163  --yy_cp;
2164  yy_current_state = *--(yy_state_ptr);
2165  (yy_lp) = yy_accept[yy_current_state];
2166  }
2167 
2168  YY_DO_BEFORE_ACTION;
2169 
2170 do_action: /* This label is used only to access EOF actions. */
2171 
2172  switch ( yy_act )
2173  { /* beginning of action switch */
2174 
2175 case 1:
2176 YY_RULE_SETUP
2177 #line 544 "pyscanner.l"
2178 { // start of a function/method definition with indent
2179  DBG_CTX((stderr,"Found def at %d\n",yyLineNr));
2180  g_indent=computeIndent(pyscannerYYtext);
2181  searchFoundDef();
2182  BEGIN( FunctionDec );
2183  }
2184  YY_BREAK
2185 case 2:
2186 YY_RULE_SETUP
2187 #line 550 "pyscanner.l"
2188 { // start of a function/method definition
2189  searchFoundDef();
2190  BEGIN( FunctionDec );
2191  }
2192  YY_BREAK
2193 case 3:
2194 YY_RULE_SETUP
2195 #line 555 "pyscanner.l"
2196 { // start of a class definition with indent
2197  DBG_CTX((stderr,"Found class at %d\n",yyLineNr));
2198  g_indent=computeIndent(pyscannerYYtext);
2199  searchFoundClass();
2200  BEGIN( ClassDec ) ;
2201  }
2202  YY_BREAK
2203 case 4:
2204 YY_RULE_SETUP
2205 #line 561 "pyscanner.l"
2206 { // start of a class definition
2207  searchFoundClass();
2208  BEGIN( ClassDec ) ;
2209  }
2210  YY_BREAK
2211 case 5:
2212 #line 566 "pyscanner.l"
2213 case 6:
2214 YY_RULE_SETUP
2215 #line 566 "pyscanner.l"
2216 { // start of an from import
2217  g_packageCommentAllowed = FALSE;
2218  BEGIN( FromMod );
2219  }
2220  YY_BREAK
2221 case 7:
2222 #line 572 "pyscanner.l"
2223 case 8:
2224 YY_RULE_SETUP
2225 #line 572 "pyscanner.l"
2226 { // start of an import statement
2227  g_packageCommentAllowed = FALSE;
2228  BEGIN( Import );
2229  }
2230  YY_BREAK
2231 case 9:
2232 YY_RULE_SETUP
2233 #line 576 "pyscanner.l"
2234 { // property
2235  current->section = Entry::VARIABLE_SEC;
2236  current->mtype = Property;
2237  current->name = QCString(pyscannerYYtext).stripWhiteSpace();
2238  current->fileName = yyFileName;
2239  current->startLine = yyLineNr;
2240  current->bodyLine = yyLineNr;
2241  g_packageCommentAllowed = FALSE;
2242  BEGIN(VariableDec);
2243  }
2244  YY_BREAK
2245 case 10:
2246 /* rule 10 can match eol */
2247 YY_RULE_SETUP
2248 #line 586 "pyscanner.l"
2249 { // variable
2250  if (g_search_count) REJECT;
2251  g_indent=computeIndent(pyscannerYYtext);
2252  current->section = Entry::VARIABLE_SEC;
2253  current->name = QCString(pyscannerYYtext).stripWhiteSpace();
2254  current->fileName = yyFileName;
2255  current->startLine = yyLineNr;
2256  current->bodyLine = yyLineNr;
2257  g_packageCommentAllowed = FALSE;
2258  BEGIN(VariableDec);
2259  }
2260  YY_BREAK
2261 case 11:
2262 /* rule 11 can match eol */
2263 YY_RULE_SETUP
2264 #line 597 "pyscanner.l"
2265 { // list of variables, we cannot place the default value
2266  // so we will skip it later on in a general rule
2267  // Also note ")" this is to catch also (a,b). the "("
2268  // is caught in the rule: [(], the ")" will be handled in [)]
2269  if (g_search_count > 1) REJECT;
2270  g_indent=computeIndent(pyscannerYYtext);
2271  current->section = Entry::VARIABLE_SEC;
2272  current->name = QCString(pyscannerYYtext).stripWhiteSpace();
2273  current->fileName = yyFileName;
2274  current->startLine = yyLineNr;
2275  current->bodyLine = yyLineNr;
2276  g_packageCommentAllowed = FALSE;
2277  newVariable();
2278  }
2279  YY_BREAK
2280 case 12:
2281 YY_RULE_SETUP
2282 #line 611 "pyscanner.l"
2283 { // start of a single quoted string
2284  g_stringContext=YY_START;
2285  g_copyString=0;
2286  g_packageCommentAllowed = FALSE;
2287  BEGIN( SingleQuoteString );
2288  }
2289  YY_BREAK
2290 case 13:
2291 YY_RULE_SETUP
2292 #line 617 "pyscanner.l"
2293 { // start of a double quoted string
2294  g_stringContext=YY_START;
2295  g_copyString=0;
2296  g_packageCommentAllowed = FALSE;
2297  BEGIN( DoubleQuoteString );
2298  }
2299  YY_BREAK
2300 case 14:
2301 YY_RULE_SETUP
2302 #line 623 "pyscanner.l"
2303 {
2304  gstat=TRUE;
2305  }
2306  YY_BREAK
2307 case 15:
2308 YY_RULE_SETUP
2309 #line 626 "pyscanner.l"
2310 { // Unix type script comment
2311  if (yyLineNr != 1) REJECT;
2312  }
2313  YY_BREAK
2314 case 16:
2315 YY_RULE_SETUP
2316 #line 629 "pyscanner.l"
2317 { // normal comment
2318  g_packageCommentAllowed = FALSE;
2319  }
2320  YY_BREAK
2321 case 17:
2322 YY_RULE_SETUP
2323 #line 632 "pyscanner.l"
2324 { // some other identifier
2325  g_packageCommentAllowed = FALSE;
2326  }
2327  YY_BREAK
2328 case 18:
2329 YY_RULE_SETUP
2330 #line 635 "pyscanner.l"
2331 {
2332  g_curIndent=computeIndent(pyscannerYYtext);
2333  }
2334  YY_BREAK
2335 case 19:
2336 /* rule 19 can match eol */
2337 YY_RULE_SETUP
2338 #line 639 "pyscanner.l"
2339 { // new line
2340  lineCount();
2341  }
2342  YY_BREAK
2343 case 20:
2344 YY_RULE_SETUP
2345 #line 643 "pyscanner.l"
2346 { // start of a comment block
2347  initTriDoubleQuoteBlock();
2348  BEGIN(TripleComment);
2349  }
2350  YY_BREAK
2351 case 21:
2352 YY_RULE_SETUP
2353 #line 648 "pyscanner.l"
2354 { // start of a comment block
2355  initTriSingleQuoteBlock();
2356  BEGIN(TripleComment);
2357  }
2358  YY_BREAK
2359 case 22:
2360 /* rule 22 can match eol */
2361 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscannerYYtext */
2362 (yy_c_buf_p) = yy_cp = yy_bp + 2;
2363 YY_DO_BEFORE_ACTION; /* set up pyscannerYYtext again */
2364 YY_RULE_SETUP
2365 #line 653 "pyscanner.l"
2366 { // start of a special comment
2367  g_curIndent=computeIndent(pyscannerYYtext);
2368  g_packageCommentAllowed = FALSE;
2369  initSpecialBlock();
2370  BEGIN(SpecialComment);
2371  }
2372  YY_BREAK
2373 case 23:
2374 YY_RULE_SETUP
2375 #line 659 "pyscanner.l"
2376 { // we have to do something with (
2377  g_search_count += 1;
2378  }
2379  YY_BREAK
2380 case 24:
2381 YY_RULE_SETUP
2382 #line 662 "pyscanner.l"
2383 { // we have to do something with )
2384  g_search_count -= 1;
2385  }
2386  YY_BREAK
2387 case 25:
2388 YY_RULE_SETUP
2389 #line 665 "pyscanner.l"
2390 { // any other character...
2391  // This is the major default
2392  // that should catch everything
2393  // else in Body.
2394  }
2395  YY_BREAK
2396 
2397 
2398 case 26:
2399 YY_RULE_SETUP
2400 #line 673 "pyscanner.l"
2401 { // python3 style imports
2402  }
2403  YY_BREAK
2404 case 27:
2405 YY_RULE_SETUP
2406 #line 675 "pyscanner.l"
2407 { // from package import
2408  g_packageName=pyscannerYYtext;
2409  }
2410  YY_BREAK
2411 case 28:
2412 YY_RULE_SETUP
2413 #line 678 "pyscanner.l"
2414 {
2415  BEGIN(FromModItem);
2416  }
2417  YY_BREAK
2418 case 29:
2419 /* rule 29 can match eol */
2420 YY_RULE_SETUP
2421 #line 681 "pyscanner.l"
2422 {
2423  incLineNr();
2424  BEGIN(Search);
2425  }
2426  YY_BREAK
2427 case 30:
2428 YY_RULE_SETUP
2429 #line 685 "pyscanner.l"
2430 {
2431  }
2432  YY_BREAK
2433 case 31:
2434 YY_RULE_SETUP
2435 #line 687 "pyscanner.l"
2436 {
2437  unput(*pyscannerYYtext);
2438  BEGIN(Search);
2439  }
2440  YY_BREAK
2441 
2442 
2443 case 32:
2444 YY_RULE_SETUP
2445 #line 694 "pyscanner.l"
2446 { // import all
2447  QCString item=g_packageName;
2448  current->name=removeRedundantWhiteSpace(substitute(item,".","::"));
2449  current->fileName = yyFileName;
2450  //printf("Adding using directive: found:%s:%d name=%s\n",yyFileName.data(),yyLineNr,current->name.data());
2451  current->section=Entry::USINGDIR_SEC;
2452  current_root->addSubEntry(current);
2453  current = new Entry ;
2454  initEntry();
2455  BEGIN(Search);
2456  }
2457  YY_BREAK
2458 case 33:
2459 YY_RULE_SETUP
2460 #line 705 "pyscanner.l"
2461 {
2462  QCString item=g_packageName+"."+pyscannerYYtext;
2463  current->name=removeRedundantWhiteSpace(substitute(item,".","::"));
2464  current->fileName = yyFileName;
2465  //printf("Adding using declaration: found:%s:%d name=%s\n",yyFileName.data(),yyLineNr,current->name.data());
2466  current->section=Entry::USINGDECL_SEC;
2467  current_root->addSubEntry(current);
2468  current = new Entry ;
2469  initEntry();
2470  }
2471  YY_BREAK
2472 case 34:
2473 YY_RULE_SETUP
2474 #line 715 "pyscanner.l"
2475 {
2476  QCString item=g_packageName+"."+pyscannerYYtext;
2477  current->name=removeRedundantWhiteSpace(substitute(item,".","::"));
2478  current->fileName = yyFileName;
2479  //printf("Adding using declaration: found:%s:%d name=%s\n",yyFileName.data(),yyLineNr,current->name.data());
2480  current->section=Entry::USINGDECL_SEC;
2481  current_root->addSubEntry(current);
2482  current = new Entry ;
2483  initEntry();
2484  BEGIN(Search);
2485  }
2486  YY_BREAK
2487 case 35:
2488 /* rule 35 can match eol */
2489 YY_RULE_SETUP
2490 #line 726 "pyscanner.l"
2491 {
2492  incLineNr();
2493  BEGIN(Search);
2494  }
2495  YY_BREAK
2496 case 36:
2497 YY_RULE_SETUP
2498 #line 730 "pyscanner.l"
2499 {
2500  }
2501  YY_BREAK
2502 case 37:
2503 YY_RULE_SETUP
2504 #line 732 "pyscanner.l"
2505 {
2506  }
2507  YY_BREAK
2508 case 38:
2509 YY_RULE_SETUP
2510 #line 734 "pyscanner.l"
2511 {
2512  unput(*pyscannerYYtext);
2513  BEGIN(Search);
2514  }
2515  YY_BREAK
2516 
2517 
2518 case 39:
2519 YY_RULE_SETUP
2520 #line 741 "pyscanner.l"
2521 {
2522  current->name=removeRedundantWhiteSpace(substitute(pyscannerYYtext,".","::"));
2523  current->fileName = yyFileName;
2524  //printf("Adding using declaration: found:%s:%d name=%s\n",yyFileName.data(),yyLineNr,current->name.data());
2525  current->section=Entry::USINGDECL_SEC;
2526  current_root->addSubEntry(current);
2527  current = new Entry ;
2528  initEntry();
2529  BEGIN(Search);
2530  }
2531  YY_BREAK
2532 case 40:
2533 /* rule 40 can match eol */
2534 YY_RULE_SETUP
2535 #line 751 "pyscanner.l"
2536 {
2537  incLineNr();
2538  BEGIN(Search);
2539  }
2540  YY_BREAK
2541 case 41:
2542 YY_RULE_SETUP
2543 #line 755 "pyscanner.l"
2544 {
2545  }
2546  YY_BREAK
2547 case 42:
2548 YY_RULE_SETUP
2549 #line 757 "pyscanner.l"
2550 {
2551  unput(*pyscannerYYtext);
2552  BEGIN(Search);
2553  }
2554  YY_BREAK
2555 
2556 
2557 case 43:
2558 YY_RULE_SETUP
2559 #line 764 "pyscanner.l"
2560 {
2561  DBG_CTX((stderr,"Found instance method variable %s in %s at %d\n",&pyscannerYYtext[5],current_root->name.data(),yyLineNr));
2562  current->name=&pyscannerYYtext[5];
2563  current->section=Entry::VARIABLE_SEC;
2564  current->fileName = yyFileName;
2565  current->startLine = yyLineNr;
2566  current->bodyLine = yyLineNr;
2567  current->type.resize(0);
2568  if (current->name.at(0)=='_') // mark as private
2569  {
2570  current->protection=Private;
2571  }
2572  newEntry();
2573  }
2574  YY_BREAK
2575 case 44:
2576 YY_RULE_SETUP
2577 #line 778 "pyscanner.l"
2578 {
2579  DBG_CTX((stderr,"Found class method variable %s in %s at %d\n",&pyscannerYYtext[4],current_root->name.data(),yyLineNr));
2580  current->name=&pyscannerYYtext[4];
2581  current->section=Entry::VARIABLE_SEC;
2582  current->fileName = yyFileName;
2583  current->startLine = yyLineNr;
2584  current->bodyLine = yyLineNr;
2585  current->type.resize(0);
2586  if (current->name.at(0)=='_') // mark as private
2587  {
2588  current->protection=Private;
2589  }
2590  newEntry();
2591  }
2592  YY_BREAK
2593 case 45:
2594 YY_RULE_SETUP
2595 #line 792 "pyscanner.l"
2596 { // start of a comment block
2597  initTriDoubleQuoteBlock();
2598  BEGIN(TripleComment);
2599  }
2600  YY_BREAK
2601 case 46:
2602 YY_RULE_SETUP
2603 #line 797 "pyscanner.l"
2604 { // start of a comment block
2605  initTriSingleQuoteBlock();
2606  BEGIN(TripleComment);
2607  }
2608  YY_BREAK
2609 case 47:
2610 /* rule 47 can match eol */
2611 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscannerYYtext */
2612 (yy_c_buf_p) = yy_cp = yy_bp + 2;
2613 YY_DO_BEFORE_ACTION; /* set up pyscannerYYtext again */
2614 YY_RULE_SETUP
2615 #line 802 "pyscanner.l"
2616 { // start of a special comment
2617  initSpecialBlock();
2618  BEGIN(SpecialComment);
2619  }
2620  YY_BREAK
2621 case 48:
2622 YY_RULE_SETUP
2623 #line 806 "pyscanner.l"
2624 { // #
2625  }
2626  YY_BREAK
2627 case 49:
2628 YY_RULE_SETUP
2629 #line 808 "pyscanner.l"
2630 { // start of a single quoted string
2631  g_stringContext=YY_START;
2632  g_copyString=0;
2633  BEGIN( SingleQuoteString );
2634  }
2635  YY_BREAK
2636 case 50:
2637 YY_RULE_SETUP
2638 #line 813 "pyscanner.l"
2639 { // start of a double quoted string
2640  g_stringContext=YY_START;
2641  g_copyString=0;
2642  BEGIN( DoubleQuoteString );
2643  }
2644  YY_BREAK
2645 case 51:
2646 /* rule 51 can match eol */
2647 YY_RULE_SETUP
2648 #line 818 "pyscanner.l"
2649 { incLineNr(); }
2650  YY_BREAK
2651 case 52:
2652 YY_RULE_SETUP
2653 #line 819 "pyscanner.l"
2654 // identifiers
2655  YY_BREAK
2656 case 53:
2657 YY_RULE_SETUP
2658 #line 820 "pyscanner.l"
2659 // other uninteresting stuff
2660  YY_BREAK
2661 case 54:
2662 YY_RULE_SETUP
2663 #line 821 "pyscanner.l"
2664 // anything else
2665  YY_BREAK
2666 
2667 
2668 case 55:
2669 /* rule 55 can match eol */
2670 YY_RULE_SETUP
2671 #line 825 "pyscanner.l"
2672 {
2673  DBG_CTX((stderr,"indent %d<=%d\n",computeIndent(&pyscannerYYtext[1]),g_indent));
2674  if (computeIndent(&pyscannerYYtext[1])<=g_indent)
2675  {
2676  int i;
2677  for (i=(int)pyscannerYYleng-1;i>=0;i--)
2678  {
2679  unput(pyscannerYYtext[i]);
2680  }
2681  endOfDef();
2682  //YY_CURRENT_BUFFER->yy_at_bol=TRUE;
2683  BEGIN(Search);
2684  }
2685  else
2686  {
2687  incLineNr();
2688  current->program+=pyscannerYYtext;
2689  }
2690  }
2691  YY_BREAK
2692 case 56:
2693 /* rule 56 can match eol */
2694 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscannerYYtext */
2695 (yy_c_buf_p) = yy_cp -= 2;
2696 YY_DO_BEFORE_ACTION; /* set up pyscannerYYtext again */
2697 YY_RULE_SETUP
2698 #line 844 "pyscanner.l"
2699 {
2700  if (computeIndent(&pyscannerYYtext[1])<=g_indent)
2701  {
2702  int i;
2703  for (i=(int)pyscannerYYleng-1;i>=0;i--)
2704  {
2705  unput(pyscannerYYtext[i]);
2706  }
2707  endOfDef();
2708  //YY_CURRENT_BUFFER->yy_at_bol=TRUE;
2709  BEGIN(Search);
2710  }
2711  else
2712  {
2713  incLineNr();
2714  current->program+=pyscannerYYtext;
2715  }
2716  }
2717  YY_BREAK
2718 case YY_STATE_EOF(FunctionBody):
2719 #line 862 "pyscanner.l"
2720 {
2721  endOfDef();
2722  yyterminate();
2723  }
2724  YY_BREAK
2725 case 57:
2726 /* rule 57 can match eol */
2727 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscannerYYtext */
2728 (yy_c_buf_p) = yy_cp -= 1;
2729 YY_DO_BEFORE_ACTION; /* set up pyscannerYYtext again */
2730 YY_RULE_SETUP
2731 #line 866 "pyscanner.l"
2732 { // skip empty line
2733  current->program+=pyscannerYYtext;
2734  }
2735  YY_BREAK
2736 case 58:
2737 YY_RULE_SETUP
2738 #line 869 "pyscanner.l"
2739 { // something at indent >0
2740  current->program+=pyscannerYYtext;
2741  g_curIndent = computeIndent(pyscannerYYtext);
2742  if (g_curIndent<=g_indent)
2743  // jumped out of the function
2744  {
2745  endOfDef(1);
2746  BEGIN(Search);
2747  }
2748  }
2749  YY_BREAK
2750 case 59:
2751 YY_RULE_SETUP
2752 #line 879 "pyscanner.l"
2753 { // start of a single quoted string
2754  current->program+=pyscannerYYtext;
2755  g_stringContext=YY_START;
2756  g_specialBlock = FALSE;
2757  g_copyString=&current->program;
2758  BEGIN( SingleQuoteString );
2759  }
2760  YY_BREAK
2761 case 60:
2762 YY_RULE_SETUP
2763 #line 886 "pyscanner.l"
2764 { // start of a double quoted string
2765  current->program+=pyscannerYYtext;
2766  g_stringContext=YY_START;
2767  g_specialBlock = FALSE;
2768  g_copyString=&current->program;
2769  BEGIN( DoubleQuoteString );
2770  }
2771  YY_BREAK
2772 case 61:
2773 YY_RULE_SETUP
2774 #line 893 "pyscanner.l"
2775 { // non-special stuff
2776  current->program+=pyscannerYYtext;
2777  g_specialBlock = FALSE;
2778  }
2779  YY_BREAK
2780 case 62:
2781 YY_RULE_SETUP
2782 #line 897 "pyscanner.l"
2783 { // normal comment
2784  current->program+=pyscannerYYtext;
2785  }
2786  YY_BREAK
2787 case 63:
2788 YY_RULE_SETUP
2789 #line 900 "pyscanner.l"
2790 { // comment half way
2791  current->program+=pyscannerYYtext;
2792  }
2793  YY_BREAK
2794 case 64:
2795 /* rule 64 can match eol */
2796 YY_RULE_SETUP
2797 #line 903 "pyscanner.l"
2798 {
2799  incLineNr();
2800  current->program+=pyscannerYYtext;
2801  }
2802  YY_BREAK
2803 case 65:
2804 YY_RULE_SETUP
2805 #line 907 "pyscanner.l"
2806 { // any character
2807  current->program+=*pyscannerYYtext;
2808  g_specialBlock = FALSE;
2809  }
2810  YY_BREAK
2811 case 66:
2812 YY_RULE_SETUP
2813 #line 912 "pyscanner.l"
2814 { // start of a comment block
2815  current->program+=pyscannerYYtext;
2816  initTriDoubleQuoteBlock();
2817  BEGIN(TripleComment);
2818  }
2819  YY_BREAK
2820 case 67:
2821 YY_RULE_SETUP
2822 #line 918 "pyscanner.l"
2823 { // start of a comment block
2824  current->program+=pyscannerYYtext;
2825  initTriSingleQuoteBlock();
2826  BEGIN(TripleComment);
2827  }
2828  YY_BREAK
2829 case 68:
2830 /* rule 68 can match eol */
2831 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscannerYYtext */
2832 (yy_c_buf_p) = yy_cp = yy_bp + 2;
2833 YY_DO_BEFORE_ACTION; /* set up pyscannerYYtext again */
2834 YY_RULE_SETUP
2835 #line 924 "pyscanner.l"
2836 { // start of a special comment
2837  initSpecialBlock();
2838  BEGIN(SpecialComment);
2839  }
2840  YY_BREAK
2841 
2842 
2843 case 69:
2844 YY_RULE_SETUP
2845 #line 933 "pyscanner.l"
2846 {
2847  //found function name
2848  if (current->type.isEmpty())
2849  {
2850  current->type = "def";
2851  }
2852  current->name = pyscannerYYtext;
2853  current->name = current->name.stripWhiteSpace();
2854  newFunction();
2855  }
2856  YY_BREAK
2857 case 70:
2858 YY_RULE_SETUP
2859 #line 943 "pyscanner.l"
2860 { // function without arguments
2861  g_specialBlock = TRUE; // expecting a docstring
2862  bodyEntry = current;
2863  current->bodyLine = yyLineNr;
2864  BEGIN( FunctionBody );
2865  }
2866  YY_BREAK
2867 case 71:
2868 YY_RULE_SETUP
2869 #line 950 "pyscanner.l"
2870 {
2871  BEGIN( FunctionParams );
2872  }
2873  YY_BREAK
2874 
2875 
2876 case 72:
2877 YY_RULE_SETUP
2878 #line 956 "pyscanner.l"
2879 {
2880  }
2881  YY_BREAK
2882 case 73:
2883 YY_RULE_SETUP
2884 #line 959 "pyscanner.l"
2885 { // Name of parameter
2886  lineCount();
2887  Argument *a = new Argument;
2888  current->argList->append(a);
2889  current->argList->getLast()->name = QCString(pyscannerYYtext).stripWhiteSpace();
2890  current->argList->getLast()->type = "";
2891  }
2892  YY_BREAK
2893 case 74:
2894 YY_RULE_SETUP
2895 #line 966 "pyscanner.l"
2896 { // default value
2897  // TODO: this rule is too simple, need to be able to
2898  // match things like =")" as well!
2899  g_defVal.resize(0);
2900  g_braceCount=0;
2901  BEGIN(FunctionParamDefVal);
2902  }
2903  YY_BREAK
2904 case 75:
2905 YY_RULE_SETUP
2906 #line 974 "pyscanner.l"
2907 { // end of parameter list
2908  current->args = argListToString(current->argList);
2909  }
2910  YY_BREAK
2911 case 76:
2912 YY_RULE_SETUP
2913 #line 978 "pyscanner.l"
2914 {
2915  g_specialBlock = TRUE; // expecting a docstring
2916  bodyEntry = current;
2917  current->bodyLine = yyLineNr;
2918  BEGIN( FunctionBody );
2919  }
2920  YY_BREAK
2921 case 77:
2922 YY_RULE_SETUP
2923 #line 984 "pyscanner.l"
2924 { // a comment
2925  }
2926  YY_BREAK
2927 case 78:
2928 YY_RULE_SETUP
2929 #line 986 "pyscanner.l"
2930 { // Default rule inside arguments.
2931  }
2932  YY_BREAK
2933 
2934 
2935 case 79:
2936 YY_RULE_SETUP
2937 #line 992 "pyscanner.l"
2938 { // internal opening brace
2939  g_braceCount++;
2940  g_defVal+=*pyscannerYYtext;
2941  }
2942  YY_BREAK
2943 case 80:
2944 #line 997 "pyscanner.l"
2945 case 81:
2946 YY_RULE_SETUP
2947 #line 997 "pyscanner.l"
2948 {
2949  if (g_braceCount==0) // end of default argument
2950  {
2951  if (current->argList->getLast())
2952  {
2953  current->argList->getLast()->defval=g_defVal.stripWhiteSpace();
2954  }
2955  if (*pyscannerYYtext == ')')
2956  current->args = argListToString(current->argList);
2957  BEGIN(FunctionParams);
2958  }
2959  else // continue
2960  {
2961  if (*pyscannerYYtext == ')')g_braceCount--;
2962  g_defVal+=*pyscannerYYtext;
2963  }
2964  }
2965  YY_BREAK
2966 case 82:
2967 YY_RULE_SETUP
2968 #line 1014 "pyscanner.l"
2969 {
2970  g_defVal+=*pyscannerYYtext;
2971  }
2972  YY_BREAK
2973 case 83:
2974 /* rule 83 can match eol */
2975 YY_RULE_SETUP
2976 #line 1017 "pyscanner.l"
2977 {
2978  g_defVal+=*pyscannerYYtext;
2979  incLineNr();
2980  }
2981  YY_BREAK
2982 
2983 
2984 case 84:
2985 /* rule 84 can match eol */
2986 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscannerYYtext */
2987 (yy_c_buf_p) = yy_cp = yy_bp + 1;
2988 YY_DO_BEFORE_ACTION; /* set up pyscannerYYtext again */
2989 YY_RULE_SETUP
2990 #line 1025 "pyscanner.l"
2991 { // new def at indent 0
2992  incLineNr();
2993  endOfDef();
2994  //g_hideClassDocs = FALSE;
2995  //YY_CURRENT_BUFFER->yy_at_bol=TRUE;
2996  BEGIN(Search);
2997  }
2998  YY_BREAK
2999 case 85:
3000 /* rule 85 can match eol */
3001 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscannerYYtext */
3002 (yy_c_buf_p) = yy_cp = yy_bp + 1;
3003 YY_DO_BEFORE_ACTION; /* set up pyscannerYYtext again */
3004 YY_RULE_SETUP
3005 #line 1032 "pyscanner.l"
3006 { // start of a special comment at indent 0
3007  incLineNr();
3008  endOfDef();
3009  //g_hideClassDocs = FALSE;
3010  //YY_CURRENT_BUFFER->yy_at_bol=TRUE;
3011  BEGIN(Search);
3012  }
3013  YY_BREAK
3014 case 86:
3015 /* rule 86 can match eol */
3016 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscannerYYtext */
3017 (yy_c_buf_p) = yy_cp -= 1;
3018 YY_DO_BEFORE_ACTION; /* set up pyscannerYYtext again */
3019 YY_RULE_SETUP
3020 #line 1039 "pyscanner.l"
3021 { // skip empty line
3022  current->program+=pyscannerYYtext;
3023  }
3024  YY_BREAK
3025 case YY_STATE_EOF(ClassBody):
3026 #line 1042 "pyscanner.l"
3027 {
3028  endOfDef();
3029  yyterminate();
3030  }
3031  YY_BREAK
3032 case 87:
3033 YY_RULE_SETUP
3034 #line 1046 "pyscanner.l"
3035 { // something at indent >0
3036  g_curIndent=computeIndent(pyscannerYYtext);
3037  DBG_CTX((stderr,"g_curIndent=%d g_indent=%d\n",g_curIndent,g_indent));
3038  if (g_curIndent<=g_indent)
3039  // jumped out of the class/method
3040  {
3041  endOfDef(1);
3042  g_indent=g_curIndent;
3043  // make sure the next rule matches ^...
3044  //YY_CURRENT_BUFFER->yy_at_bol=TRUE;
3045  //g_hideClassDocs = FALSE;
3046  BEGIN(Search);
3047  }
3048  else
3049  {
3050  current->program+=pyscannerYYtext;
3051  }
3052  }
3053  YY_BREAK
3054 case 88:
3055 YY_RULE_SETUP
3056 #line 1064 "pyscanner.l"
3057 { // start of a single quoted string
3058  current->program+=*pyscannerYYtext;
3059  g_stringContext=YY_START;
3060  g_specialBlock = FALSE;
3061  g_copyString=&current->program;
3062  BEGIN( SingleQuoteString );
3063  }
3064  YY_BREAK
3065 case 89:
3066 YY_RULE_SETUP
3067 #line 1071 "pyscanner.l"
3068 { // start of a double quoted string
3069  current->program+=*pyscannerYYtext;
3070  g_stringContext=YY_START;
3071  g_specialBlock = FALSE;
3072  g_copyString=&current->program;
3073  BEGIN( DoubleQuoteString );
3074  }
3075  YY_BREAK
3076 case 90:
3077 YY_RULE_SETUP
3078 #line 1078 "pyscanner.l"
3079 { // non-special stuff
3080  current->program+=pyscannerYYtext;
3081  g_specialBlock = FALSE;
3082  //g_hideClassDocs = FALSE;
3083  }
3084  YY_BREAK
3085 case 91:
3086 /* rule 91 can match eol */
3087 YY_RULE_SETUP
3088 #line 1083 "pyscanner.l"
3089 {
3090  current->program+=*pyscannerYYtext;
3091  incLineNr();
3092  }
3093  YY_BREAK
3094 case 92:
3095 YY_RULE_SETUP
3096 #line 1087 "pyscanner.l"
3097 { // normal comment
3098  current->program+=pyscannerYYtext;
3099  }
3100  YY_BREAK
3101 case 93:
3102 YY_RULE_SETUP
3103 #line 1090 "pyscanner.l"
3104 { // any character
3105  g_specialBlock = FALSE;
3106  current->program+=*pyscannerYYtext;
3107  }
3108  YY_BREAK
3109 case 94:
3110 YY_RULE_SETUP
3111 #line 1094 "pyscanner.l"
3112 { // start of a comment block
3113  //if (!g_hideClassDocs)
3114  current->program+=pyscannerYYtext;
3115  initTriDoubleQuoteBlock();
3116  BEGIN(TripleComment);
3117  }
3118  YY_BREAK
3119 case 95:
3120 YY_RULE_SETUP
3121 #line 1101 "pyscanner.l"
3122 { // start of a comment block
3123  //if (!g_hideClassDocs)
3124  current->program+=pyscannerYYtext;
3125  initTriSingleQuoteBlock();
3126  BEGIN(TripleComment);
3127  }
3128  YY_BREAK
3129 
3130 case 96:
3131 YY_RULE_SETUP
3132 #line 1109 "pyscanner.l"
3133 {
3134  if (current->type.isEmpty())
3135  {
3136  current->type = "class";
3137  }
3138 
3139  current->section = Entry::CLASS_SEC;
3140  current->name = pyscannerYYtext;
3141 
3142  // prepend scope in case of nested classes
3143  if (current_root->section&Entry::SCOPE_MASK)
3144  {
3145  //printf("*** Prepending scope %s to class %s\n",current_root->name.data(),current->name.data());
3146  current->name.prepend(current_root->name+"::");
3147  }
3148 
3149  current->name = current->name.stripWhiteSpace();
3150  current->fileName = yyFileName;
3151  docBlockContext = YY_START;
3152  docBlockInBody = FALSE;
3153  docBlockJavaStyle = FALSE;
3154  docBlock.resize(0);
3155 
3156  BEGIN(ClassInheritance);
3157  }
3158  YY_BREAK
3159 
3160 case 97:
3161 YY_RULE_SETUP
3162 #line 1136 "pyscanner.l"
3163 { // syntactic sugar for the list
3164  }
3165  YY_BREAK
3166 case 98:
3167 YY_RULE_SETUP
3168 #line 1139 "pyscanner.l"
3169 { // begin of the class definition
3170  g_specialBlock = TRUE; // expecting a docstring
3171  current->bodyLine = yyLineNr;
3172  current->program.resize(0);
3173  BEGIN(ClassCaptureIndent);
3174  }
3175  YY_BREAK
3176 case 99:
3177 YY_RULE_SETUP
3178 #line 1146 "pyscanner.l"
3179 {
3180  current->extends->append(
3181  new BaseInfo(substitute(pyscannerYYtext,".","::"),Public,Normal)
3182  );
3183  //Has base class-do stuff
3184  }
3185  YY_BREAK
3186 
3187 
3188 case 100:
3189 /* rule 100 can match eol */
3190 YY_RULE_SETUP
3191 #line 1156 "pyscanner.l"
3192 {
3193  // Blankline - ignore, keep looking for indentation.
3194  lineCount();
3195  current->program+=pyscannerYYtext;
3196  }
3197  YY_BREAK
3198 case 101:
3199 YY_RULE_SETUP
3200 #line 1162 "pyscanner.l"
3201 { // start of a comment block
3202  initTriDoubleQuoteBlock();
3203  current->program+=pyscannerYYtext;
3204  BEGIN(TripleComment);
3205  }
3206  YY_BREAK
3207 case 102:
3208 YY_RULE_SETUP
3209 #line 1168 "pyscanner.l"
3210 { // start of a comment block
3211  initTriSingleQuoteBlock();
3212  current->program+=pyscannerYYtext;
3213  BEGIN(TripleComment);
3214  }
3215  YY_BREAK
3216 case 103:
3217 YY_RULE_SETUP
3218 #line 1174 "pyscanner.l"
3219 {
3220  current->program+=pyscannerYYtext;
3221  //current->startLine = yyLineNr;
3222  g_curIndent=computeIndent(pyscannerYYtext);
3223  bodyEntry = current;
3224  DBG_CTX((stderr,"setting indent %d\n",g_curIndent));
3225  //printf("current->program=[%s]\n",current->program.data());
3226  //g_hideClassDocs = TRUE;
3227  BEGIN(ClassBody);
3228  }
3229  YY_BREAK
3230 case 104:
3231 YY_RULE_SETUP
3232 #line 1185 "pyscanner.l"
3233 {
3234 
3235  // Just pushback an empty class, and
3236  // resume parsing the body.
3237  newEntry();
3238  current->program+=pyscannerYYtext;
3239 
3240  // printf("Failed to find indent - skipping!");
3241  BEGIN( Search );
3242  }
3243  YY_BREAK
3244 
3245 
3246 case 105:
3247 YY_RULE_SETUP
3248 #line 1199 "pyscanner.l"
3249 { // the assignment operator
3250  //printf("====== VariableDec at line %d\n",yyLineNr);
3251  g_start_init = TRUE;
3252  current->initializer = pyscannerYYtext;
3253  current->initializer += " ";
3254  }
3255  YY_BREAK
3256 case 106:
3257 YY_RULE_SETUP
3258 #line 1205 "pyscanner.l"
3259 { // spaces
3260  }
3261  YY_BREAK
3262 case 107:
3263 YY_RULE_SETUP
3264 #line 1207 "pyscanner.l"
3265 { // integer value
3266  current->type = "int";
3267  current->initializer += pyscannerYYtext;
3268  BEGIN(VariableEnd);
3269  }
3270  YY_BREAK
3271 case 108:
3272 YY_RULE_SETUP
3273 #line 1212 "pyscanner.l"
3274 { // floating point value
3275  current->type = "float";
3276  current->initializer += pyscannerYYtext;
3277  BEGIN(VariableEnd);
3278  }
3279  YY_BREAK
3280 case 109:
3281 YY_RULE_SETUP
3282 #line 1217 "pyscanner.l"
3283 { // boolean value
3284  current->type = "bool";
3285  current->initializer += pyscannerYYtext;
3286  BEGIN(VariableEnd);
3287  }
3288  YY_BREAK
3289 case 110:
3290 YY_RULE_SETUP
3291 #line 1222 "pyscanner.l"
3292 { // string
3293  current->type = "string";
3294  current->initializer += pyscannerYYtext;
3295  g_copyString=&current->initializer;
3296  g_stringContext=VariableEnd;
3297  BEGIN( SingleQuoteString );
3298  }
3299  YY_BREAK
3300 case 111:
3301 YY_RULE_SETUP
3302 #line 1229 "pyscanner.l"
3303 { // string
3304  current->type = "string";
3305  current->initializer += pyscannerYYtext;
3306  g_copyString=&current->initializer;
3307  g_stringContext=VariableEnd;
3308  BEGIN( DoubleQuoteString );
3309  }
3310  YY_BREAK
3311 case 112:
3312 YY_RULE_SETUP
3313 #line 1236 "pyscanner.l"
3314 { // start of a comment block
3315  current->type = "string";
3316  current->initializer += pyscannerYYtext;
3317  g_doubleQuote=TRUE;
3318  g_copyString=&current->initializer;
3319  g_stringContext=VariableEnd;
3320  BEGIN(TripleString);
3321  }
3322  YY_BREAK
3323 case 113:
3324 YY_RULE_SETUP
3325 #line 1245 "pyscanner.l"
3326 { // start of a comment block
3327  current->type = "string";
3328  current->initializer += pyscannerYYtext;
3329  g_doubleQuote=FALSE;
3330  g_copyString=&current->initializer;
3331  g_stringContext=VariableEnd;
3332  BEGIN(TripleString);
3333  }
3334  YY_BREAK
3335 case 114:
3336 YY_RULE_SETUP
3337 #line 1253 "pyscanner.l"
3338 { // tuple, only when direct after =
3339  if (current->mtype!=Property && g_start_init)
3340  {
3341  current->type = "tuple";
3342  }
3343  current->initializer+=*pyscannerYYtext;
3344  g_atomStart='(';
3345  g_atomEnd=')';
3346  g_atomCount=1;
3347  BEGIN( VariableAtom );
3348  }
3349  YY_BREAK
3350 case 115:
3351 YY_RULE_SETUP
3352 #line 1264 "pyscanner.l"
3353 { // list
3354  if (g_start_init) current->type = "list";
3355  current->initializer+=*pyscannerYYtext;
3356  g_atomStart='[';
3357  g_atomEnd=']';
3358  g_atomCount=1;
3359  BEGIN( VariableAtom );
3360  }
3361  YY_BREAK
3362 case 116:
3363 YY_RULE_SETUP
3364 #line 1272 "pyscanner.l"
3365 { // dictionary
3366  if (g_start_init) current->type = "dictionary";
3367  current->initializer+=*pyscannerYYtext;
3368  g_atomStart='{';
3369  g_atomEnd='}';
3370  g_atomCount=1;
3371  BEGIN( VariableAtom );
3372  }
3373  YY_BREAK
3374 case 117:
3375 YY_RULE_SETUP
3376 #line 1280 "pyscanner.l"
3377 { // comment
3378  BEGIN( VariableEnd );
3379  }
3380  YY_BREAK
3381 case 118:
3382 YY_RULE_SETUP
3383 #line 1283 "pyscanner.l"
3384 {
3385  g_start_init = FALSE;
3386  current->initializer+=pyscannerYYtext;
3387  }
3388  YY_BREAK
3389 case 119:
3390 YY_RULE_SETUP
3391 #line 1287 "pyscanner.l"
3392 {
3393  g_start_init = FALSE;
3394  current->initializer+=*pyscannerYYtext;
3395  }
3396  YY_BREAK
3397 case 120:
3398 /* rule 120 can match eol */
3399 YY_RULE_SETUP
3400 #line 1291 "pyscanner.l"
3401 {
3402  unput('\n');
3403  BEGIN( VariableEnd );
3404  }
3405  YY_BREAK
3406 
3407 
3408 case 121:
3409 YY_RULE_SETUP
3410 #line 1298 "pyscanner.l"
3411 {
3412  current->initializer+=*pyscannerYYtext;
3413  if (g_atomStart==*pyscannerYYtext)
3414  {
3415  g_atomCount++;
3416  }
3417  }
3418  YY_BREAK
3419 case 122:
3420 YY_RULE_SETUP
3421 #line 1305 "pyscanner.l"
3422 {
3423  current->initializer+=*pyscannerYYtext;
3424  if (g_atomEnd==*pyscannerYYtext)
3425  {
3426  g_atomCount--;
3427  }
3428  if (g_atomCount==0)
3429  {
3430  g_start_init = FALSE;
3431  BEGIN(VariableDec);
3432  }
3433  }
3434  YY_BREAK
3435 case 123:
3436 YY_RULE_SETUP
3437 #line 1317 "pyscanner.l"
3438 { // start of a comment block
3439  g_specialBlock = FALSE;
3440  current->program+=pyscannerYYtext;
3441  initTriDoubleQuoteBlock();
3442  BEGIN(TripleComment);
3443  }
3444  YY_BREAK
3445 case 124:
3446 YY_RULE_SETUP
3447 #line 1324 "pyscanner.l"
3448 { // start of a comment block
3449  g_specialBlock = FALSE;
3450  current->program+=pyscannerYYtext;
3451  initTriSingleQuoteBlock();
3452  BEGIN(TripleComment);
3453  }
3454  YY_BREAK
3455 case 125:
3456 YY_RULE_SETUP
3457 #line 1330 "pyscanner.l"
3458 {
3459  g_stringContext=YY_START;
3460  current->initializer+="'";
3461  g_copyString=&current->initializer;
3462  BEGIN( SingleQuoteString );
3463  }
3464  YY_BREAK
3465 case 126:
3466 YY_RULE_SETUP
3467 #line 1336 "pyscanner.l"
3468 {
3469  g_stringContext=YY_START;
3470  current->initializer+="\"";
3471  g_copyString=&current->initializer;
3472  BEGIN( DoubleQuoteString );
3473  }
3474  YY_BREAK
3475 case 127:
3476 YY_RULE_SETUP
3477 #line 1342 "pyscanner.l"
3478 {
3479  current->initializer+=pyscannerYYtext;
3480  }
3481  YY_BREAK
3482 case 128:
3483 YY_RULE_SETUP
3484 #line 1345 "pyscanner.l"
3485 {
3486  current->initializer+=*pyscannerYYtext;
3487  }
3488  YY_BREAK
3489 case 129:
3490 /* rule 129 can match eol */
3491 YY_RULE_SETUP
3492 #line 1348 "pyscanner.l"
3493 {
3494  current->initializer+=*pyscannerYYtext;
3495  incLineNr();
3496  }
3497  YY_BREAK
3498 
3499 
3500 case 130:
3501 /* rule 130 can match eol */
3502 YY_RULE_SETUP
3503 #line 1356 "pyscanner.l"
3504 {
3505  incLineNr();
3506  newVariable();
3507  BEGIN(Search);
3508  }
3509  YY_BREAK
3510 case 131:
3511 YY_RULE_SETUP
3512 #line 1361 "pyscanner.l"
3513 {
3514  unput(*pyscannerYYtext);
3515  newVariable();
3516  BEGIN(Search);
3517  }
3518  YY_BREAK
3519 case YY_STATE_EOF(VariableEnd):
3520 #line 1366 "pyscanner.l"
3521 { yyterminate();
3522  newEntry();
3523  }
3524  YY_BREAK
3525 
3526 
3527 case 132:
3528 #line 1373 "pyscanner.l"
3529 case 133:
3530 YY_RULE_SETUP
3531 #line 1373 "pyscanner.l"
3532 {
3533  // printf("Expected module block %d special=%d\n",g_expectModuleDocs,g_specialBlock);
3534  if (g_doubleQuote==(pyscannerYYtext[0]=='"'))
3535  {
3536  if (g_specialBlock) // expecting a docstring
3537  {
3538  QCString actualDoc=docBlock;
3539  if (!docBlockSpecial) // legacy unformatted docstring
3540  {
3541  actualDoc.prepend("\\verbatim ");
3542  actualDoc.append("\\endverbatim ");
3543  }
3544  //printf("-------> current=%p bodyEntry=%p\n",current,bodyEntry);
3545  handleCommentBlock(actualDoc, FALSE);
3546  }
3547  else if (g_packageCommentAllowed) // expecting module docs
3548  {
3549  QCString actualDoc=docBlock;
3550  if (!docBlockSpecial) // legacy unformatted docstring
3551  {
3552  actualDoc.prepend("\\verbatim ");
3553  actualDoc.append("\\endverbatim ");
3554  }
3555  actualDoc.prepend("\\namespace "+g_moduleScope+"\\_linebr ");
3556  handleCommentBlock(actualDoc, FALSE);
3557  }
3558  if ((docBlockContext==ClassBody /*&& !g_hideClassDocs*/) ||
3559  docBlockContext==FunctionBody)
3560  {
3561  current->program+=docBlock;
3562  current->program+=pyscannerYYtext;
3563  }
3564  //if (g_hideClassDocs)
3565  //{
3566  // current->startLine = yyLineNr;
3567  //}
3568  //g_hideClassDocs=FALSE;
3569  BEGIN(docBlockContext);
3570  }
3571  else
3572  {
3573  docBlock += pyscannerYYtext;
3574  }
3575  g_packageCommentAllowed = FALSE;
3576  }
3577  YY_BREAK
3578 case 134:
3579 YY_RULE_SETUP
3580 #line 1420 "pyscanner.l"
3581 { // leading whitespace
3582  int indent = computeIndent(pyscannerYYtext);
3583  if (indent>=g_curIndent)
3584  { // strip g_curIndent amount of whitespace
3585  int i;
3586  for (i=0;i<indent-g_curIndent;i++) docBlock+=' ';
3587  DBG_CTX((stderr,"stripping indent %d\n",g_curIndent));
3588  }
3589  else
3590  {
3591  DBG_CTX((stderr,"not stripping: %d<%d\n",indent,g_curIndent));
3592  docBlock += pyscannerYYtext;
3593  }
3594  }
3595  YY_BREAK
3596 case 135:
3597 YY_RULE_SETUP
3598 #line 1434 "pyscanner.l"
3599 {
3600  docBlock += pyscannerYYtext;
3601  }
3602  YY_BREAK
3603 case 136:
3604 /* rule 136 can match eol */
3605 YY_RULE_SETUP
3606 #line 1437 "pyscanner.l"
3607 {
3608  incLineNr();
3609  docBlock += pyscannerYYtext;
3610  }
3611  YY_BREAK
3612 case 137:
3613 YY_RULE_SETUP
3614 #line 1441 "pyscanner.l"
3615 { // espaced char
3616  docBlock += pyscannerYYtext;
3617  }
3618  YY_BREAK
3619 case 138:
3620 YY_RULE_SETUP
3621 #line 1444 "pyscanner.l"
3622 {
3623  docBlock += pyscannerYYtext;
3624  }
3625  YY_BREAK
3626 
3627 
3628 case 139:
3629 YY_RULE_SETUP
3630 #line 1450 "pyscanner.l"
3631 { // skip leading hashes
3632  }
3633  YY_BREAK
3634 case 140:
3635 /* rule 140 can match eol */
3636 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscannerYYtext */
3637 (yy_c_buf_p) = yy_cp = yy_bp + 1;
3638 YY_DO_BEFORE_ACTION; /* set up pyscannerYYtext again */
3639 YY_RULE_SETUP
3640 #line 1452 "pyscanner.l"
3641 { // continuation of the comment on the next line
3642  docBlock+='\n';
3643  docBrief = FALSE;
3644  startCommentBlock(FALSE);
3645  incLineNr();
3646  }
3647  YY_BREAK
3648 case 141:
3649 YY_RULE_SETUP
3650 #line 1458 "pyscanner.l"
3651 { // any other stuff
3652  docBlock+=pyscannerYYtext;
3653  }
3654  YY_BREAK
3655 case 142:
3656 /* rule 142 can match eol */
3657 YY_RULE_SETUP
3658 #line 1461 "pyscanner.l"
3659 { // new line that ends the comment
3660  handleCommentBlock(docBlock, docBrief);
3661  incLineNr();
3662  BEGIN(docBlockContext);
3663  }
3664  YY_BREAK
3665 case 143:
3666 YY_RULE_SETUP
3667 #line 1466 "pyscanner.l"
3668 { // anything we missed
3669  docBlock+=*pyscannerYYtext;
3670  }
3671  YY_BREAK
3672 
3673 
3674 case 144:
3675 /* rule 144 can match eol */
3676 YY_RULE_SETUP
3677 #line 1472 "pyscanner.l"
3678 { // line continuation
3679  addToString(pyscannerYYtext);
3680  incLineNr();
3681  }
3682  YY_BREAK
3683 case 145:
3684 YY_RULE_SETUP
3685 #line 1476 "pyscanner.l"
3686 { // espaced char
3687  addToString(pyscannerYYtext);
3688  }
3689  YY_BREAK
3690 case 146:
3691 YY_RULE_SETUP
3692 #line 1479 "pyscanner.l"
3693 { // tripple double quotes
3694  addToString(pyscannerYYtext);
3695  }
3696  YY_BREAK
3697 case 147:
3698 YY_RULE_SETUP
3699 #line 1482 "pyscanner.l"
3700 { // end of the string
3701  addToString(pyscannerYYtext);
3702  BEGIN(g_stringContext);
3703  }
3704  YY_BREAK
3705 case 148:
3706 YY_RULE_SETUP
3707 #line 1486 "pyscanner.l"
3708 { // normal chars
3709  addToString(pyscannerYYtext);
3710  }
3711  YY_BREAK
3712 case 149:
3713 YY_RULE_SETUP
3714 #line 1489 "pyscanner.l"
3715 { // normal char
3716  addToString(pyscannerYYtext);
3717  }
3718  YY_BREAK
3719 
3720 
3721 case 150:
3722 /* rule 150 can match eol */
3723 YY_RULE_SETUP
3724 #line 1495 "pyscanner.l"
3725 { // line continuation
3726  addToString(pyscannerYYtext);
3727  incLineNr();
3728  }
3729  YY_BREAK
3730 case 151:
3731 YY_RULE_SETUP
3732 #line 1499 "pyscanner.l"
3733 { // espaced char
3734  addToString(pyscannerYYtext);
3735  }
3736  YY_BREAK
3737 case 152:
3738 YY_RULE_SETUP
3739 #line 1502 "pyscanner.l"
3740 { // tripple single quotes
3741  addToString(pyscannerYYtext);
3742  }
3743  YY_BREAK
3744 case 153:
3745 YY_RULE_SETUP
3746 #line 1505 "pyscanner.l"
3747 { // end of the string
3748  addToString(pyscannerYYtext);
3749  BEGIN(g_stringContext);
3750  }
3751  YY_BREAK
3752 case 154:
3753 YY_RULE_SETUP
3754 #line 1509 "pyscanner.l"
3755 { // normal chars
3756  addToString(pyscannerYYtext);
3757  }
3758  YY_BREAK
3759 case 155:
3760 YY_RULE_SETUP
3761 #line 1512 "pyscanner.l"
3762 { // normal char
3763  addToString(pyscannerYYtext);
3764  }
3765  YY_BREAK
3766 
3767 
3768 case 156:
3769 #line 1519 "pyscanner.l"
3770 case 157:
3771 YY_RULE_SETUP
3772 #line 1519 "pyscanner.l"
3773 {
3774  *g_copyString += pyscannerYYtext;
3775  if (g_doubleQuote==(pyscannerYYtext[0]=='"'))
3776  {
3777  BEGIN(g_stringContext);
3778  }
3779  }
3780  YY_BREAK
3781 case 158:
3782 /* rule 158 can match eol */
3783 YY_RULE_SETUP
3784 #line 1528 "pyscanner.l"
3785 {
3786  lineCount();
3787  *g_copyString += pyscannerYYtext;
3788  }
3789  YY_BREAK
3790 case 159:
3791 /* rule 159 can match eol */
3792 YY_RULE_SETUP
3793 #line 1532 "pyscanner.l"
3794 {
3795  incLineNr();
3796  *g_copyString += pyscannerYYtext;
3797  }
3798  YY_BREAK
3799 case 160:
3800 YY_RULE_SETUP
3801 #line 1536 "pyscanner.l"
3802 {
3803  *g_copyString += *pyscannerYYtext;
3804  }
3805  YY_BREAK
3806 
3807 /* ------------ End rules -------------- */
3808 /*
3809 <*>({NONEMPTY}|{EXPCHAR}|{BB}) { // This should go one character at a time.
3810  // printf("[pyscanner] '%s' [ state %d ] [line %d] no match\n",
3811  // pyscannerYYtext, YY_START, yyLineNr);
3812 
3813  }
3814  */
3815 case 161:
3816 /* rule 161 can match eol */
3817 YY_RULE_SETUP
3818 #line 1551 "pyscanner.l"
3819 {
3820  //printf("[pyscanner] %d NEWLINE [line %d] no match\n",
3821  // YY_START, yyLineNr);
3822 
3823  lineCount();
3824  }
3825  YY_BREAK
3826 case 162:
3827 YY_RULE_SETUP
3828 #line 1558 "pyscanner.l"
3829 {
3830  //printf("[pyscanner] '%s' [ state %d ] [line %d] no match\n",
3831  // pyscannerYYtext, YY_START, yyLineNr);
3832 
3833  }
3834  YY_BREAK
3835 case 163:
3836 YY_RULE_SETUP
3837 #line 1565 "pyscanner.l"
3838 ECHO;
3839  YY_BREAK
3840 #line 3841 "/nova/app/home/novasoft/doxygen/doxygen-1.8.11/build/generated_src/pyscanner.cpp"
3841  case YY_STATE_EOF(INITIAL):
3842  case YY_STATE_EOF(Search):
3843  case YY_STATE_EOF(SearchMemVars):
3844  case YY_STATE_EOF(TryClassDocString):
3845  case YY_STATE_EOF(TripleComment):
3846  case YY_STATE_EOF(SpecialComment):
3847  case YY_STATE_EOF(FunctionDec):
3848  case YY_STATE_EOF(FunctionParams):
3849  case YY_STATE_EOF(FunctionParamDefVal):
3850  case YY_STATE_EOF(ClassDec):
3851  case YY_STATE_EOF(ClassInheritance):
3852  case YY_STATE_EOF(ClassCaptureIndent):
3853  case YY_STATE_EOF(VariableDec):
3854  case YY_STATE_EOF(VariableAtom):
3855  case YY_STATE_EOF(SingleQuoteString):
3856  case YY_STATE_EOF(DoubleQuoteString):
3857  case YY_STATE_EOF(TripleString):
3858  case YY_STATE_EOF(FromMod):
3859  case YY_STATE_EOF(FromModItem):
3860  case YY_STATE_EOF(Import):
3861  yyterminate();
3862 
3863  case YY_END_OF_BUFFER:
3864  {
3865  /* Amount of text matched not including the EOB char. */
3866  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
3867 
3868  /* Undo the effects of YY_DO_BEFORE_ACTION. */
3869  *yy_cp = (yy_hold_char);
3870  YY_RESTORE_YY_MORE_OFFSET
3871 
3872  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
3873  {
3874  /* We're scanning a new file or input source. It's
3875  * possible that this happened because the user
3876  * just pointed pyscannerYYin at a new source and called
3877  * pyscannerYYlex(). If so, then we have to assure
3878  * consistency between YY_CURRENT_BUFFER and our
3879  * globals. Here is the right place to do so, because
3880  * this is the first action (other than possibly a
3881  * back-up) that will match for the new input source.
3882  */
3883  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
3884  YY_CURRENT_BUFFER_LVALUE->yy_input_file = pyscannerYYin;
3885  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
3886  }
3887 
3888  /* Note that here we test for yy_c_buf_p "<=" to the position
3889  * of the first EOB in the buffer, since yy_c_buf_p will
3890  * already have been incremented past the NUL character
3891  * (since all states make transitions on EOB to the
3892  * end-of-buffer state). Contrast this with the test
3893  * in input().
3894  */
3895  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
3896  { /* This was really a NUL. */
3897  yy_state_type yy_next_state;
3898 
3899  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
3900 
3901  yy_current_state = yy_get_previous_state( );
3902 
3903  /* Okay, we're now positioned to make the NUL
3904  * transition. We couldn't have
3905  * yy_get_previous_state() go ahead and do it
3906  * for us because it doesn't know how to deal
3907  * with the possibility of jamming (and we don't
3908  * want to build jamming into it because then it
3909  * will run more slowly).
3910  */
3911 
3912  yy_next_state = yy_try_NUL_trans( yy_current_state );
3913 
3914  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3915 
3916  if ( yy_next_state )
3917  {
3918  /* Consume the NUL. */
3919  yy_cp = ++(yy_c_buf_p);
3920  yy_current_state = yy_next_state;
3921  goto yy_match;
3922  }
3923 
3924  else
3925  {
3926  yy_cp = (yy_c_buf_p);
3927  goto yy_find_action;
3928  }
3929  }
3930 
3931  else switch ( yy_get_next_buffer( ) )
3932  {
3933  case EOB_ACT_END_OF_FILE:
3934  {
3935  (yy_did_buffer_switch_on_eof) = 0;
3936 
3937  if ( pyscannerYYwrap( ) )
3938  {
3939  /* Note: because we've taken care in
3940  * yy_get_next_buffer() to have set up
3941  * pyscannerYYtext, we can now set up
3942  * yy_c_buf_p so that if some total
3943  * hoser (like flex itself) wants to
3944  * call the scanner after we return the
3945  * YY_NULL, it'll still work - another
3946  * YY_NULL will get returned.
3947  */
3948  (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
3949 
3950  yy_act = YY_STATE_EOF(YY_START);
3951  goto do_action;
3952  }
3953 
3954  else
3955  {
3956  if ( ! (yy_did_buffer_switch_on_eof) )
3957  YY_NEW_FILE;
3958  }
3959  break;
3960  }
3961 
3962  case EOB_ACT_CONTINUE_SCAN:
3963  (yy_c_buf_p) =
3964  (yytext_ptr) + yy_amount_of_matched_text;
3965 
3966  yy_current_state = yy_get_previous_state( );
3967 
3968  yy_cp = (yy_c_buf_p);
3969  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3970  goto yy_match;
3971 
3972  case EOB_ACT_LAST_MATCH:
3973  (yy_c_buf_p) =
3974  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
3975 
3976  yy_current_state = yy_get_previous_state( );
3977 
3978  yy_cp = (yy_c_buf_p);
3979  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
3980  goto yy_find_action;
3981  }
3982  break;
3983  }
3984 
3985  default:
3986  YY_FATAL_ERROR(
3987  "fatal flex scanner internal error--no action found" );
3988  } /* end of action switch */
3989  } /* end of scanning one token */
3990 } /* end of pyscannerYYlex */
3991 
3992 /* yy_get_next_buffer - try to read in a new buffer
3993  *
3994  * Returns a code representing an action:
3995  * EOB_ACT_LAST_MATCH -
3996  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
3997  * EOB_ACT_END_OF_FILE - end of file
3998  */
3999 static int yy_get_next_buffer (void)
4000 {
4001  register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
4002  register char *source = (yytext_ptr);
4003  register int number_to_move, i;
4004  int ret_val;
4005 
4006  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
4007  YY_FATAL_ERROR(
4008  "fatal flex scanner internal error--end of buffer missed" );
4009 
4010  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
4011  { /* Don't try to fill the buffer, so this is an EOF. */
4012  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
4013  {
4014  /* We matched a single character, the EOB, so
4015  * treat this as a final EOF.
4016  */
4017  return EOB_ACT_END_OF_FILE;
4018  }
4019 
4020  else
4021  {
4022  /* We matched some text prior to the EOB, first
4023  * process it.
4024  */
4025  return EOB_ACT_LAST_MATCH;
4026  }
4027  }
4028 
4029  /* Try to read more data. */
4030 
4031  /* First move last chars to start of buffer. */
4032  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
4033 
4034  for ( i = 0; i < number_to_move; ++i )
4035  *(dest++) = *(source++);
4036 
4037  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
4038  /* don't do the read, it's not guaranteed to return an EOF,
4039  * just force an EOF
4040  */
4041  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
4042 
4043  else
4044  {
4045  int num_to_read =
4046  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
4047 
4048  while ( num_to_read <= 0 )
4049  { /* Not enough room in the buffer - grow it. */
4050 
4051  YY_FATAL_ERROR(
4052 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
4053 
4054  }
4055 
4056  if ( num_to_read > YY_READ_BUF_SIZE )
4057  num_to_read = YY_READ_BUF_SIZE;
4058 
4059  /* Read in more data. */
4060  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
4061  (yy_n_chars), (size_t) num_to_read );
4062 
4063  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4064  }
4065 
4066  if ( (yy_n_chars) == 0 )
4067  {
4068  if ( number_to_move == YY_MORE_ADJ )
4069  {
4070  ret_val = EOB_ACT_END_OF_FILE;
4071  pyscannerYYrestart(pyscannerYYin );
4072  }
4073 
4074  else
4075  {
4076  ret_val = EOB_ACT_LAST_MATCH;
4077  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
4078  YY_BUFFER_EOF_PENDING;
4079  }
4080  }
4081 
4082  else
4083  ret_val = EOB_ACT_CONTINUE_SCAN;
4084 
4085  if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
4086  /* Extend the array by 50%, plus the number we really need. */
4087  yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
4088  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) pyscannerYYrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
4089  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
4090  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
4091  }
4092 
4093  (yy_n_chars) += number_to_move;
4094  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
4095  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
4096 
4097  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
4098 
4099  return ret_val;
4100 }
4101 
4102 /* yy_get_previous_state - get the state just before the EOB char was reached */
4103 
4104  static yy_state_type yy_get_previous_state (void)
4105 {
4106  register yy_state_type yy_current_state;
4107  register char *yy_cp;
4108 
4109  yy_current_state = (yy_start);
4110  yy_current_state += YY_AT_BOL();
4111 
4112  (yy_state_ptr) = (yy_state_buf);
4113  *(yy_state_ptr)++ = yy_current_state;
4114 
4115  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
4116  {
4117  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
4118  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
4119  {
4120  yy_current_state = (int) yy_def[yy_current_state];
4121  if ( yy_current_state >= 496 )
4122  yy_c = yy_meta[(unsigned int) yy_c];
4123  }
4124  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
4125  *(yy_state_ptr)++ = yy_current_state;
4126  }
4127 
4128  return yy_current_state;
4129 }
4130 
4131 /* yy_try_NUL_trans - try to make a transition on the NUL character
4132  *
4133  * synopsis
4134  * next_state = yy_try_NUL_trans( current_state );
4135  */
4136  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
4137 {
4138  register int yy_is_jam;
4139 
4140  register YY_CHAR yy_c = 1;
4141  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
4142  {
4143  yy_current_state = (int) yy_def[yy_current_state];
4144  if ( yy_current_state >= 496 )
4145  yy_c = yy_meta[(unsigned int) yy_c];
4146  }
4147  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
4148  yy_is_jam = (yy_current_state == 495);
4149  if ( ! yy_is_jam )
4150  *(yy_state_ptr)++ = yy_current_state;
4151 
4152  return yy_is_jam ? 0 : yy_current_state;
4153 }
4154 
4155  static void yyunput (int c, register char * yy_bp )
4156 {
4157  register char *yy_cp;
4158 
4159  yy_cp = (yy_c_buf_p);
4160 
4161  /* undo effects of setting up pyscannerYYtext */
4162  *yy_cp = (yy_hold_char);
4163 
4164  if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
4165  { /* need to shift things up to make room */
4166  /* +2 for EOB chars. */
4167  register int number_to_move = (yy_n_chars) + 2;
4168  register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
4169  YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
4170  register char *source =
4171  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
4172 
4173  while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
4174  *--dest = *--source;
4175 
4176  yy_cp += (int) (dest - source);
4177  yy_bp += (int) (dest - source);
4178  YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
4179  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
4180 
4181  if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
4182  YY_FATAL_ERROR( "flex scanner push-back overflow" );
4183  }
4184 
4185  *--yy_cp = (char) c;
4186 
4187  (yytext_ptr) = yy_bp;
4188  (yy_hold_char) = *yy_cp;
4189  (yy_c_buf_p) = yy_cp;
4190 }
4191 
4192 #ifndef YY_NO_INPUT
4193 #ifdef __cplusplus
4194  static int yyinput (void)
4195 #else
4196  static int input (void)
4197 #endif
4198 
4199 {
4200  int c;
4201 
4202  *(yy_c_buf_p) = (yy_hold_char);
4203 
4204  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
4205  {
4206  /* yy_c_buf_p now points to the character we want to return.
4207  * If this occurs *before* the EOB characters, then it's a
4208  * valid NUL; if not, then we've hit the end of the buffer.
4209  */
4210  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
4211  /* This was really a NUL. */
4212  *(yy_c_buf_p) = '\0';
4213 
4214  else
4215  { /* need more input */
4216  int offset = (yy_c_buf_p) - (yytext_ptr);
4217  ++(yy_c_buf_p);
4218 
4219  switch ( yy_get_next_buffer( ) )
4220  {
4221  case EOB_ACT_LAST_MATCH:
4222  /* This happens because yy_g_n_b()
4223  * sees that we've accumulated a
4224  * token and flags that we need to
4225  * try matching the token before
4226  * proceeding. But for input(),
4227  * there's no matching to consider.
4228  * So convert the EOB_ACT_LAST_MATCH
4229  * to EOB_ACT_END_OF_FILE.
4230  */
4231 
4232  /* Reset buffer status. */
4233  pyscannerYYrestart(pyscannerYYin );
4234 
4235  /*FALLTHROUGH*/
4236 
4237  case EOB_ACT_END_OF_FILE:
4238  {
4239  if ( pyscannerYYwrap( ) )
4240  return EOF;
4241 
4242  if ( ! (yy_did_buffer_switch_on_eof) )
4243  YY_NEW_FILE;
4244 #ifdef __cplusplus
4245  return yyinput();
4246 #else
4247  return input();
4248 #endif
4249  }
4250 
4251  case EOB_ACT_CONTINUE_SCAN:
4252  (yy_c_buf_p) = (yytext_ptr) + offset;
4253  break;
4254  }
4255  }
4256  }
4257 
4258  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
4259  *(yy_c_buf_p) = '\0'; /* preserve pyscannerYYtext */
4260  (yy_hold_char) = *++(yy_c_buf_p);
4261 
4262  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
4263 
4264  return c;
4265 }
4266 #endif /* ifndef YY_NO_INPUT */
4267 
4268 /** Immediately switch to a different input stream.
4269  * @param input_file A readable stream.
4270  *
4271  * @note This function does not reset the start condition to @c INITIAL .
4272  */
4273  void pyscannerYYrestart (FILE * input_file )
4274 {
4275 
4276  if ( ! YY_CURRENT_BUFFER ){
4277  pyscannerYYensure_buffer_stack ();
4278  YY_CURRENT_BUFFER_LVALUE =
4279  pyscannerYY_create_buffer(pyscannerYYin,YY_BUF_SIZE );
4280  }
4281 
4282  pyscannerYY_init_buffer(YY_CURRENT_BUFFER,input_file );
4283  pyscannerYY_load_buffer_state( );
4284 }
4285 
4286 /** Switch to a different input buffer.
4287  * @param new_buffer The new input buffer.
4288  *
4289  */
4290  void pyscannerYY_switch_to_buffer (YY_BUFFER_STATE new_buffer )
4291 {
4292 
4293  /* TODO. We should be able to replace this entire function body
4294  * with
4295  * pyscannerYYpop_buffer_state();
4296  * pyscannerYYpush_buffer_state(new_buffer);
4297  */
4298  pyscannerYYensure_buffer_stack ();
4299  if ( YY_CURRENT_BUFFER == new_buffer )
4300  return;
4301 
4302  if ( YY_CURRENT_BUFFER )
4303  {
4304  /* Flush out information for old buffer. */
4305  *(yy_c_buf_p) = (yy_hold_char);
4306  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
4307  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4308  }
4309 
4310  YY_CURRENT_BUFFER_LVALUE = new_buffer;
4311  pyscannerYY_load_buffer_state( );
4312 
4313  /* We don't actually know whether we did this switch during
4314  * EOF (pyscannerYYwrap()) processing, but the only time this flag
4315  * is looked at is after pyscannerYYwrap() is called, so it's safe
4316  * to go ahead and always set it.
4317  */
4318  (yy_did_buffer_switch_on_eof) = 1;
4319 }
4320 
4321 static void pyscannerYY_load_buffer_state (void)
4322 {
4323  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
4324  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
4325  pyscannerYYin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
4326  (yy_hold_char) = *(yy_c_buf_p);
4327 }
4328 
4329 /** Allocate and initialize an input buffer state.
4330  * @param file A readable stream.
4331  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
4332  *
4333  * @return the allocated buffer state.
4334  */
4335  YY_BUFFER_STATE pyscannerYY_create_buffer (FILE * file, int size )
4336 {
4337  YY_BUFFER_STATE b;
4338 
4339  b = (YY_BUFFER_STATE) pyscannerYYalloc(sizeof( struct yy_buffer_state ) );
4340  if ( ! b )
4341  YY_FATAL_ERROR( "out of dynamic memory in pyscannerYY_create_buffer()" );
4342 
4343  b->yy_buf_size = size;
4344 
4345  /* yy_ch_buf has to be 2 characters longer than the size given because
4346  * we need to put in 2 end-of-buffer characters.
4347  */
4348  b->yy_ch_buf = (char *) pyscannerYYalloc(b->yy_buf_size + 2 );
4349  if ( ! b->yy_ch_buf )
4350  YY_FATAL_ERROR( "out of dynamic memory in pyscannerYY_create_buffer()" );
4351 
4352  b->yy_is_our_buffer = 1;
4353 
4354  pyscannerYY_init_buffer(b,file );
4355 
4356  return b;
4357 }
4358 
4359 /** Destroy the buffer.
4360  * @param b a buffer created with pyscannerYY_create_buffer()
4361  *
4362  */
4363  void pyscannerYY_delete_buffer (YY_BUFFER_STATE b )
4364 {
4365 
4366  if ( ! b )
4367  return;
4368 
4369  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
4370  YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
4371 
4372  if ( b->yy_is_our_buffer )
4373  pyscannerYYfree((void *) b->yy_ch_buf );
4374 
4375  pyscannerYYfree((void *) b );
4376 }
4377 
4378 /* Initializes or reinitializes a buffer.
4379  * This function is sometimes called more than once on the same buffer,
4380  * such as during a pyscannerYYrestart() or at EOF.
4381  */
4382  static void pyscannerYY_init_buffer (YY_BUFFER_STATE b, FILE * file )
4383 
4384 {
4385  int oerrno = errno;
4386 
4387  pyscannerYY_flush_buffer(b );
4388 
4389  b->yy_input_file = file;
4390  b->yy_fill_buffer = 1;
4391 
4392  /* If b is the current buffer, then pyscannerYY_init_buffer was _probably_
4393  * called from pyscannerYYrestart() or through yy_get_next_buffer.
4394  * In that case, we don't want to reset the lineno or column.
4395  */
4396  if (b != YY_CURRENT_BUFFER){
4397  b->yy_bs_lineno = 1;
4398  b->yy_bs_column = 0;
4399  }
4400 
4401  b->yy_is_interactive = 0;
4402 
4403  errno = oerrno;
4404 }
4405 
4406 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
4407  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
4408  *
4409  */
4410  void pyscannerYY_flush_buffer (YY_BUFFER_STATE b )
4411 {
4412  if ( ! b )
4413  return;
4414 
4415  b->yy_n_chars = 0;
4416 
4417  /* We always need two end-of-buffer characters. The first causes
4418  * a transition to the end-of-buffer state. The second causes
4419  * a jam in that state.
4420  */
4421  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
4422  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
4423 
4424  b->yy_buf_pos = &b->yy_ch_buf[0];
4425 
4426  b->yy_at_bol = 1;
4427  b->yy_buffer_status = YY_BUFFER_NEW;
4428 
4429  if ( b == YY_CURRENT_BUFFER )
4430  pyscannerYY_load_buffer_state( );
4431 }
4432 
4433 /** Pushes the new state onto the stack. The new state becomes
4434  * the current state. This function will allocate the stack
4435  * if necessary.
4436  * @param new_buffer The new state.
4437  *
4438  */
4439 void pyscannerYYpush_buffer_state (YY_BUFFER_STATE new_buffer )
4440 {
4441  if (new_buffer == NULL)
4442  return;
4443 
4444  pyscannerYYensure_buffer_stack();
4445 
4446  /* This block is copied from pyscannerYY_switch_to_buffer. */
4447  if ( YY_CURRENT_BUFFER )
4448  {
4449  /* Flush out information for old buffer. */
4450  *(yy_c_buf_p) = (yy_hold_char);
4451  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
4452  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
4453  }
4454 
4455  /* Only push if top exists. Otherwise, replace top. */
4456  if (YY_CURRENT_BUFFER)
4457  (yy_buffer_stack_top)++;
4458  YY_CURRENT_BUFFER_LVALUE = new_buffer;
4459 
4460  /* copied from pyscannerYY_switch_to_buffer. */
4461  pyscannerYY_load_buffer_state( );
4462  (yy_did_buffer_switch_on_eof) = 1;
4463 }
4464 
4465 /** Removes and deletes the top of the stack, if present.
4466  * The next element becomes the new top.
4467  *
4468  */
4469 void pyscannerYYpop_buffer_state (void)
4470 {
4471  if (!YY_CURRENT_BUFFER)
4472  return;
4473 
4474  pyscannerYY_delete_buffer(YY_CURRENT_BUFFER );
4475  YY_CURRENT_BUFFER_LVALUE = NULL;
4476  if ((yy_buffer_stack_top) > 0)
4477  --(yy_buffer_stack_top);
4478 
4479  if (YY_CURRENT_BUFFER) {
4480  pyscannerYY_load_buffer_state( );
4481  (yy_did_buffer_switch_on_eof) = 1;
4482  }
4483 }
4484 
4485 /* Allocates the stack if it does not exist.
4486  * Guarantees space for at least one push.
4487  */
4488 static void pyscannerYYensure_buffer_stack (void)
4489 {
4490  int num_to_alloc;
4491 
4492  if (!(yy_buffer_stack)) {
4493 
4494  /* First allocation is just for 2 elements, since we don't know if this
4495  * scanner will even need a stack. We use 2 instead of 1 to avoid an
4496  * immediate realloc on the next call.
4497  */
4498  num_to_alloc = 1;
4499  (yy_buffer_stack) = (struct yy_buffer_state**)pyscannerYYalloc
4500  (num_to_alloc * sizeof(struct yy_buffer_state*)
4501  );
4502  if ( ! (yy_buffer_stack) )
4503  YY_FATAL_ERROR( "out of dynamic memory in pyscannerYYensure_buffer_stack()" );
4504 
4505  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
4506 
4507  (yy_buffer_stack_max) = num_to_alloc;
4508  (yy_buffer_stack_top) = 0;
4509  return;
4510  }
4511 
4512  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
4513 
4514  /* Increase the buffer to prepare for a possible push. */
4515  int grow_size = 8 /* arbitrary grow size */;
4516 
4517  num_to_alloc = (yy_buffer_stack_max) + grow_size;
4518  (yy_buffer_stack) = (struct yy_buffer_state**)pyscannerYYrealloc
4519  ((yy_buffer_stack),
4520  num_to_alloc * sizeof(struct yy_buffer_state*)
4521  );
4522  if ( ! (yy_buffer_stack) )
4523  YY_FATAL_ERROR( "out of dynamic memory in pyscannerYYensure_buffer_stack()" );
4524 
4525  /* zero only the new slots.*/
4526  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
4527  (yy_buffer_stack_max) = num_to_alloc;
4528  }
4529 }
4530 
4531 /** Setup the input buffer state to scan directly from a user-specified character buffer.
4532  * @param base the character buffer
4533  * @param size the size in bytes of the character buffer
4534  *
4535  * @return the newly allocated buffer state object.
4536  */
4537 YY_BUFFER_STATE pyscannerYY_scan_buffer (char * base, yy_size_t size )
4538 {
4539  YY_BUFFER_STATE b;
4540 
4541  if ( size < 2 ||
4542  base[size-2] != YY_END_OF_BUFFER_CHAR ||
4543  base[size-1] != YY_END_OF_BUFFER_CHAR )
4544  /* They forgot to leave room for the EOB's. */
4545  return 0;
4546 
4547  b = (YY_BUFFER_STATE) pyscannerYYalloc(sizeof( struct yy_buffer_state ) );
4548  if ( ! b )
4549  YY_FATAL_ERROR( "out of dynamic memory in pyscannerYY_scan_buffer()" );
4550 
4551  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
4552  b->yy_buf_pos = b->yy_ch_buf = base;
4553  b->yy_is_our_buffer = 0;
4554  b->yy_input_file = 0;
4555  b->yy_n_chars = b->yy_buf_size;
4556  b->yy_is_interactive = 0;
4557  b->yy_at_bol = 1;
4558  b->yy_fill_buffer = 0;
4559  b->yy_buffer_status = YY_BUFFER_NEW;
4560 
4561  pyscannerYY_switch_to_buffer(b );
4562 
4563  return b;
4564 }
4565 
4566 /** Setup the input buffer state to scan a string. The next call to pyscannerYYlex() will
4567  * scan from a @e copy of @a str.
4568  * @param yystr a NUL-terminated string to scan
4569  *
4570  * @return the newly allocated buffer state object.
4571  * @note If you want to scan bytes that may contain NUL values, then use
4572  * pyscannerYY_scan_bytes() instead.
4573  */
4574 YY_BUFFER_STATE pyscannerYY_scan_string (yyconst char * yystr )
4575 {
4576 
4577  return pyscannerYY_scan_bytes(yystr,strlen(yystr) );
4578 }
4579 
4580 /** Setup the input buffer state to scan the given bytes. The next call to pyscannerYYlex() will
4581  * scan from a @e copy of @a bytes.
4582  * @param bytes the byte buffer to scan
4583  * @param len the number of bytes in the buffer pointed to by @a bytes.
4584  *
4585  * @return the newly allocated buffer state object.
4586  */
4587 YY_BUFFER_STATE pyscannerYY_scan_bytes (yyconst char * yybytes, int _yybytes_len )
4588 {
4589  YY_BUFFER_STATE b;
4590  char *buf;
4591  yy_size_t n;
4592  int i;
4593 
4594  /* Get memory for full buffer, including space for trailing EOB's. */
4595  n = _yybytes_len + 2;
4596  buf = (char *) pyscannerYYalloc(n );
4597  if ( ! buf )
4598  YY_FATAL_ERROR( "out of dynamic memory in pyscannerYY_scan_bytes()" );
4599 
4600  for ( i = 0; i < _yybytes_len; ++i )
4601  buf[i] = yybytes[i];
4602 
4603  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
4604 
4605  b = pyscannerYY_scan_buffer(buf,n );
4606  if ( ! b )
4607  YY_FATAL_ERROR( "bad buffer in pyscannerYY_scan_bytes()" );
4608 
4609  /* It's okay to grow etc. this buffer, and we should throw it
4610  * away when we're done.
4611  */
4612  b->yy_is_our_buffer = 1;
4613 
4614  return b;
4615 }
4616 
4617 #ifndef YY_EXIT_FAILURE
4618 #define YY_EXIT_FAILURE 2
4619 #endif
4620 
4621 static void yy_fatal_error (yyconst char* msg )
4622 {
4623  (void) fprintf( stderr, "%s\n", msg );
4624  exit( YY_EXIT_FAILURE );
4625 }
4626 
4627 /* Redefine yyless() so it works in section 3 code. */
4628 
4629 #undef yyless
4630 #define yyless(n) \
4631  do \
4632  { \
4633  /* Undo effects of setting up pyscannerYYtext. */ \
4634  int yyless_macro_arg = (n); \
4635  YY_LESS_LINENO(yyless_macro_arg);\
4636  pyscannerYYtext[pyscannerYYleng] = (yy_hold_char); \
4637  (yy_c_buf_p) = pyscannerYYtext + yyless_macro_arg; \
4638  (yy_hold_char) = *(yy_c_buf_p); \
4639  *(yy_c_buf_p) = '\0'; \
4640  pyscannerYYleng = yyless_macro_arg; \
4641  } \
4642  while ( 0 )
4643 
4644 /* Accessor methods (get/set functions) to struct members. */
4645 
4646 /** Get the current line number.
4647  *
4648  */
4649 int pyscannerYYget_lineno (void)
4650 {
4651 
4652  return pyscannerYYlineno;
4653 }
4654 
4655 /** Get the input stream.
4656  *
4657  */
4658 FILE *pyscannerYYget_in (void)
4659 {
4660  return pyscannerYYin;
4661 }
4662 
4663 /** Get the output stream.
4664  *
4665  */
4666 FILE *pyscannerYYget_out (void)
4667 {
4668  return pyscannerYYout;
4669 }
4670 
4671 /** Get the length of the current token.
4672  *
4673  */
4674 int pyscannerYYget_leng (void)
4675 {
4676  return pyscannerYYleng;
4677 }
4678 
4679 /** Get the current token.
4680  *
4681  */
4682 
4683 char *pyscannerYYget_text (void)
4684 {
4685  return pyscannerYYtext;
4686 }
4687 
4688 /** Set the current line number.
4689  * @param line_number
4690  *
4691  */
4692 void pyscannerYYset_lineno (int line_number )
4693 {
4694 
4695  pyscannerYYlineno = line_number;
4696 }
4697 
4698 /** Set the input stream. This does not discard the current
4699  * input buffer.
4700  * @param in_str A readable stream.
4701  *
4702  * @see pyscannerYY_switch_to_buffer
4703  */
4704 void pyscannerYYset_in (FILE * in_str )
4705 {
4706  pyscannerYYin = in_str ;
4707 }
4708 
4709 void pyscannerYYset_out (FILE * out_str )
4710 {
4711  pyscannerYYout = out_str ;
4712 }
4713 
4714 int pyscannerYYget_debug (void)
4715 {
4716  return pyscannerYY_flex_debug;
4717 }
4718 
4719 void pyscannerYYset_debug (int bdebug )
4720 {
4721  pyscannerYY_flex_debug = bdebug ;
4722 }
4723 
4724 static int yy_init_globals (void)
4725 {
4726  /* Initialization is the same as for the non-reentrant scanner.
4727  * This function is called from pyscannerYYlex_destroy(), so don't allocate here.
4728  */
4729 
4730  (yy_buffer_stack) = 0;
4731  (yy_buffer_stack_top) = 0;
4732  (yy_buffer_stack_max) = 0;
4733  (yy_c_buf_p) = (char *) 0;
4734  (yy_init) = 0;
4735  (yy_start) = 0;
4736 
4737  (yy_state_buf) = 0;
4738  (yy_state_ptr) = 0;
4739  (yy_full_match) = 0;
4740  (yy_lp) = 0;
4741 
4742 /* Defined in main.c */
4743 #ifdef YY_STDINIT
4744  pyscannerYYin = stdin;
4745  pyscannerYYout = stdout;
4746 #else
4747  pyscannerYYin = (FILE *) 0;
4748  pyscannerYYout = (FILE *) 0;
4749 #endif
4750 
4751  /* For future reference: Set errno on error, since we are called by
4752  * pyscannerYYlex_init()
4753  */
4754  return 0;
4755 }
4756 
4757 /* pyscannerYYlex_destroy is for both reentrant and non-reentrant scanners. */
4758 int pyscannerYYlex_destroy (void)
4759 {
4760 
4761  /* Pop the buffer stack, destroying each element. */
4762  while(YY_CURRENT_BUFFER){
4763  pyscannerYY_delete_buffer(YY_CURRENT_BUFFER );
4764  YY_CURRENT_BUFFER_LVALUE = NULL;
4765  pyscannerYYpop_buffer_state();
4766  }
4767 
4768  /* Destroy the stack itself. */
4769  pyscannerYYfree((yy_buffer_stack) );
4770  (yy_buffer_stack) = NULL;
4771 
4772  pyscannerYYfree ( (yy_state_buf) );
4773  (yy_state_buf) = NULL;
4774 
4775  /* Reset the globals. This is important in a non-reentrant scanner so the next time
4776  * pyscannerYYlex() is called, initialization will occur. */
4777  yy_init_globals( );
4778 
4779  return 0;
4780 }
4781 
4782 /*
4783  * Internal utility routines.
4784  */
4785 
4786 #ifndef yytext_ptr
4787 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
4788 {
4789  register int i;
4790  for ( i = 0; i < n; ++i )
4791  s1[i] = s2[i];
4792 }
4793 #endif
4794 
4795 #ifdef YY_NEED_STRLEN
4796 static int yy_flex_strlen (yyconst char * s )
4797 {
4798  register int n;
4799  for ( n = 0; s[n]; ++n )
4800  ;
4801 
4802  return n;
4803 }
4804 #endif
4805 
4806 void *pyscannerYYalloc (yy_size_t size )
4807 {
4808  return (void *) malloc( size );
4809 }
4810 
4811 void *pyscannerYYrealloc (void * ptr, yy_size_t size )
4812 {
4813  /* The cast to (char *) in the following accommodates both
4814  * implementations that use char* generic pointers, and those
4815  * that use void* generic pointers. It works with the latter
4816  * because both ANSI C and C++ allow castless assignment from
4817  * any pointer type to void*, and deal with argument conversions
4818  * as though doing an assignment.
4819  */
4820  return (void *) realloc( (char *) ptr, size );
4821 }
4822 
4823 void pyscannerYYfree (void * ptr )
4824 {
4825  free( (char *) ptr ); /* see pyscannerYYrealloc() for (char *) cast */
4826 }
4827 
4828 #define YYTABLES_NAME "yytables"
4829 
4830 #line 1565 "pyscanner.l"
4831 
4832 
4833 
4834 //----------------------------------------------------------------------------
4835 
4836 static void parseCompounds(Entry *rt)
4837 {
4838  //printf("parseCompounds(%s)\n",rt->name.data());
4839  EntryListIterator eli(*rt->children());
4840  Entry *ce;
4841  for (;(ce=eli.current());++eli)
4842  {
4843  if (!ce->program.isEmpty())
4844  {
4845  //printf("-- %s ---------\n%s\n---------------\n",
4846  // ce->name.data(),ce->program.data());
4847  // init scanner state
4848  inputString = ce->program;
4849  inputPosition = 0;
4850  pyscannerYYrestart( pyscannerYYin ) ;
4851  if (ce->section&Entry::COMPOUND_MASK)
4852  {
4853  current_root = ce ;
4854  BEGIN( Search );
4855  }
4856  else if (ce->parent())
4857  {
4858  current_root = ce->parent();
4859  //printf("Searching for member variables in %s parent=%s\n",
4860  // ce->name.data(),ce->parent->name.data());
4861  BEGIN( SearchMemVars );
4862  }
4863  yyFileName = ce->fileName;
4864  yyLineNr = ce->bodyLine ;
4865  if (current) delete current;
4866  current = new Entry;
4867  initEntry();
4868 
4869  groupEnterCompound(yyFileName,yyLineNr,ce->name);
4870 
4871  pyscannerYYlex() ;
4872  g_lexInit=TRUE;
4873  delete current; current=0;
4874  ce->program.resize(0);
4875 
4876  groupLeaveCompound(yyFileName,yyLineNr,ce->name);
4877 
4878  }
4879  parseCompounds(ce);
4880  }
4881 }
4882 
4883 //----------------------------------------------------------------------------
4884 
4885 
4886 static void parseMain(const char *fileName,const char *fileBuf,Entry *rt)
4887 {
4888  initParser();
4889 
4890  inputString = fileBuf;
4891  inputPosition = 0;
4892 
4893  protection = Public;
4894  mtype = Method;
4895  gstat = FALSE;
4896  virt = Normal;
4897  current_root = rt;
4898  g_specialBlock = FALSE;
4899 
4900 
4901  inputFile.setName(fileName);
4902  if (inputFile.open(IO_ReadOnly))
4903  {
4904  yyLineNr= 1 ;
4905  yyFileName = fileName;
4906  //setContext();
4907  msg("Parsing file %s...\n",yyFileName.data());
4908 
4909  QFileInfo fi(fileName);
4910  g_moduleScope = findPackageScope(fileName);
4911  QCString baseName=fi.baseName().utf8();
4912  if (baseName!="__init__") // package initializer file is not a package itself
4913  {
4914  if (!g_moduleScope.isEmpty())
4915  {
4916  g_moduleScope+="::";
4917  }
4918  g_moduleScope+=baseName;
4919  }
4920 
4921  current = new Entry;
4922  initEntry();
4923  current->name = g_moduleScope;
4924  current->section = Entry::NAMESPACE_SEC;
4925  current->type = "namespace";
4926  current->fileName = yyFileName;
4927  current->startLine = yyLineNr;
4928  current->bodyLine = yyLineNr;
4929 
4930  rt->addSubEntry(current);
4931 
4932  current_root = current ;
4933  initParser();
4934  current = new Entry;
4935 
4936  groupEnterFile(yyFileName,yyLineNr);
4937 
4938  current->reset();
4939  initEntry();
4940  pyscannerYYrestart( pyscannerYYin );
4941  BEGIN( Search );
4942  pyscannerYYlex();
4943  g_lexInit=TRUE;
4944 
4945  groupLeaveFile(yyFileName,yyLineNr);
4946 
4947  current_root->program.resize(0);
4948  delete current; current=0;
4949 
4950  parseCompounds(current_root);
4951 
4952  inputFile.close();
4953  }
4954 
4955 }
4956 
4957 //----------------------------------------------------------------------------
4958 
4959 static void parsePrototype(const QCString &text)
4960 {
4961  //printf("**** parsePrototype(%s) begin\n",text.data());
4962  if (text.isEmpty())
4963  {
4964  warn(yyFileName,yyLineNr,"Empty prototype found!");
4965  return;
4966  }
4967 
4968  g_specialBlock = FALSE;
4969  g_packageCommentAllowed = FALSE;
4970 
4971  const char *orgInputString;
4972  int orgInputPosition;
4973  YY_BUFFER_STATE orgState;
4974 
4975  // save scanner state
4976  orgState = YY_CURRENT_BUFFER;
4977  pyscannerYY_switch_to_buffer(pyscannerYY_create_buffer(pyscannerYYin,YY_BUF_SIZE));
4978  orgInputString = inputString;
4979  orgInputPosition = inputPosition;
4980 
4981  // set new string
4982  inputString = text;
4983  inputPosition = 0;
4984  pyscannerYYrestart( pyscannerYYin );
4985 
4986  BEGIN( FunctionDec );
4987 
4988  pyscannerYYlex();
4989  g_lexInit=TRUE;
4990 
4991  current->name = current->name.stripWhiteSpace();
4992  if (current->section == Entry::MEMBERDOC_SEC && current->args.isEmpty())
4993  current->section = Entry::VARIABLEDOC_SEC;
4994 
4995  // restore original scanner state
4996 
4997  YY_BUFFER_STATE tmpBuf = YY_CURRENT_BUFFER;
4998  pyscannerYY_switch_to_buffer(orgState);
4999  pyscannerYY_delete_buffer(tmpBuf);
5000 
5001  inputString = orgInputString;
5002  inputPosition = orgInputPosition;
5003 
5004  //printf("**** parsePrototype end\n");
5005 }
5006 
5007 void pyscanFreeScanner()
5008 {
5009 #if defined(YY_FLEX_SUBMINOR_VERSION)
5010  if (g_lexInit)
5011  {
5012  pyscannerYYlex_destroy();
5013  }
5014 #endif
5015 }
5016 
5017 //----------------------------------------------------------------------------
5018 
5019 void PythonLanguageScanner::parseInput(const char *fileName,
5020  const char *fileBuf,
5021  Entry *root,
5022  bool /*sameTranslationUnit*/,
5023  QStrList & /*filesInSameTranslationUnit*/)
5024 {
5025  g_thisParser = this;
5026  printlex(pyscannerYY_flex_debug, TRUE, __FILE__, fileName);
5027  ::parseMain(fileName,fileBuf,root);
5028  printlex(pyscannerYY_flex_debug, FALSE, __FILE__, fileName);
5029 
5030  // May print the AST for debugging purposes
5031  // printAST(global_root);
5032 }
5033 
5034 bool PythonLanguageScanner::needsPreprocessing(const QCString &)
5035 {
5036  return FALSE;
5037 }
5038 
5039 void PythonLanguageScanner::parseCode(CodeOutputInterface &codeOutIntf,
5040  const char *scopeName,
5041  const QCString &input,
5042  SrcLangExt /*lang*/,
5043  bool isExampleBlock,
5044  const char *exampleName,
5045  FileDef *fileDef,
5046  int startLine,
5047  int endLine,
5048  bool inlineFragment,
5049  MemberDef *memberDef,
5050  bool showLineNumbers,
5051  Definition *searchCtx,
5052  bool collectXRefs
5053  )
5054 {
5055  ::parsePythonCode(codeOutIntf,scopeName,input,isExampleBlock,exampleName,
5056  fileDef,startLine,endLine,inlineFragment,memberDef,
5057  showLineNumbers,searchCtx,collectXRefs);
5058 }
5059 
5060 void PythonLanguageScanner::parsePrototype(const char *text)
5061 {
5062  ::parsePrototype(text);
5063 
5064 }
5065 
5066 void PythonLanguageScanner::resetCodeParserState()
5067 {
5068  ::resetPythonCodeParserState();
5069 }
5070 
5071 //----------------------------------------------------------------------------
5072 
5073 #if !defined(YY_FLEX_SUBMINOR_VERSION)
5074 //----------------------------------------------------------------------------
5075 extern "C" { // some bogus code to keep the compiler happy
5076  void pyscannerYYdummy() { yy_flex_realloc(0,0); }
5077 }
5078 #endif
5079 
5080 
name
static QCString name
Definition: declinfo.cpp:673
yyconst
#define yyconst
Definition: pyscanner.cpp:127
Entry::program
QGString program
the program text
Definition: entry.h:256
YY_BUFFER_EOF_PENDING
#define YY_BUFFER_EOF_PENDING
Definition: pyscanner.cpp:266
Argument::type
QCString type
Definition: arguments.h:67
Entry::setParent
void setParent(Entry *parent)
Definition: entry.h:202
yy_full_lp
static int yy_full_lp
Definition: pyscanner.cpp:1352
TryClassDocString
#define TryClassDocString
Definition: pyscanner.cpp:1851
inputPosition
static int inputPosition
Definition: pyscanner.cpp:1437
QCString::resize
bool resize(uint newlen)
Definition: qcstring.h:225
protection
static Protection protection
Definition: pyscanner.cpp:1440
yy_acclist
static yyconst flex_int16_t yy_acclist[881]
Definition: pyscanner.cpp:394
Import
#define Import
Definition: pyscanner.cpp:1870
yy_buffer_state::yy_buf_pos
char * yy_buf_pos
Definition: code.cpp:213
yy_buffer_state::yy_input_file
FILE * yy_input_file
Definition: code.cpp:210
flex_int16_t
short int flex_int16_t
Definition: code.cpp:71
YY_AT_BOL
#define YY_AT_BOL()
Definition: pyscanner.cpp:350
TripleString
#define TripleString
Definition: pyscanner.cpp:1867
yy_ec
static yyconst flex_int32_t yy_ec[256]
Definition: pyscanner.cpp:553
Entry::reset
void reset()
Definition: entry.cpp:217
yy_buffer_state::yy_n_chars
int yy_n_chars
Definition: code.cpp:223
VariableAtom
#define VariableAtom
Definition: pyscanner.cpp:1864
resetPythonCodeParserState
void resetPythonCodeParserState()
Definition: pycode.cpp:4123
QCString::stripWhiteSpace
QCString stripWhiteSpace() const
Definition: qcstring.cpp:295
scope
static QCString scope
Definition: declinfo.cpp:668
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: pyscanner.cpp:1368
FunctionBody
#define FunctionBody
Definition: pyscanner.cpp:1856
Entry::stat
bool stat
static ?
Definition: entry.h:245
pyscannerYYrealloc
void * pyscannerYYrealloc(void *, yy_size_t)
Definition: pyscanner.cpp:4811
pyscannerYYrestart
void pyscannerYYrestart(FILE *input_file)
Definition: pyscanner.cpp:4273
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: pyscanner.cpp:2011
brief
bool brief
Definition: vhdljjparser.cpp:78
pyscannerYYin
FILE * pyscannerYYin
Definition: pyscanner.cpp:359
endOfDef
static void endOfDef(int correction=0)
Definition: pyscanner.cpp:1718
YY_BUFFER_NEW
#define YY_BUFFER_NEW
Definition: pyscanner.cpp:254
VariableDec
#define VariableDec
Definition: pyscanner.cpp:1862
generate_datataset.stdout
stdout
Definition: generate_datataset.py:30
FunctionParamDefVal
#define FunctionParamDefVal
Definition: pyscanner.cpp:1857
pyscannerYYpop_buffer_state
void pyscannerYYpop_buffer_state(void)
Definition: pyscanner.cpp:4469
QCString::isEmpty
bool isEmpty() const
Definition: qcstring.h:189
docBrief
static bool docBrief
Definition: pyscanner.cpp:1456
flex_uint16_t
unsigned short int flex_uint16_t
Definition: pyscanner.cpp:74
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition: pyscanner.cpp:1949
REJECT
#define REJECT
Definition: pyscanner.cpp:1356
msg
void msg(const char *fmt,...)
Definition: message.cpp:107
yy_init
static int yy_init
Definition: pyscanner.cpp:298
yy_buffer_stack
static YY_BUFFER_STATE * yy_buffer_stack
Definition: pyscanner.cpp:274
printlex
void printlex(int dbg, bool enter, const char *lexName, const char *fileName)
Definition: message.cpp:242
yy_buffer_state::yy_fill_buffer
int yy_fill_buffer
Definition: code.cpp:250
QCString::length
uint length() const
Definition: qcstring.h:195
g_packageName
static QCString g_packageName
Definition: pyscanner.cpp:1475
yy_buffer_stack_top
static size_t yy_buffer_stack_top
Definition: pyscanner.cpp:272
pyscannerYYset_extra
void pyscannerYYset_extra(YY_EXTRA_TYPE user_defined)
QList::append
void append(const type *d)
Definition: qlist.h:73
mtype
static MethodTypes mtype
Definition: pyscanner.cpp:1448
addToString
static void addToString(const char *s)
Definition: pyscanner.cpp:1730
g_packageCommentAllowed
static bool g_packageCommentAllowed
Definition: pyscanner.cpp:1483
Entry
Definition: entry.h:63
ParserInterface
Abstract interface for programming language parsers.
Definition: parserintf.h:38
Public
Definition: types.h:26
docBlockInBody
static bool docBlockInBody
Definition: pyscanner.cpp:1454
yy_full_match
static char * yy_full_match
Definition: pyscanner.cpp:1349
pyscannerYY_scan_bytes
YY_BUFFER_STATE pyscannerYY_scan_bytes(yyconst char *bytes, int len)
Definition: pyscanner.cpp:4587
EOB_ACT_END_OF_FILE
#define EOB_ACT_END_OF_FILE
Definition: pyscanner.cpp:180
Argument::defval
QCString defval
Definition: arguments.h:71
QCString::at
char & at(uint i) const
Definition: qcstring.h:326
flex_int8_t
signed char flex_int8_t
Definition: pyscanner.cpp:70
computeIndent
static int computeIndent(const char *s)
Definition: pyscanner.cpp:1550
argListToString
QCString argListToString(ArgumentList *al, bool useCanonicalType, bool showDefVals)
Definition: util.cpp:2151
YY_TRAILING_HEAD_MASK
#define YY_TRAILING_HEAD_MASK
Definition: pyscanner.cpp:1355
pyscannerYYset_in
void pyscannerYYset_in(FILE *in_str)
Definition: pyscanner.cpp:4704
Entry::briefLine
int briefLine
line number at which the brief desc. was found
Definition: entry.h:264
parsePrototype
static void parsePrototype(const QCString &text)
Definition: pyscanner.cpp:4959
YY_EXTRA_TYPE
#define YY_EXTRA_TYPE
Definition: pyscanner.cpp:1881
groupEnterCompound
void groupEnterCompound(const char *fileName, int line, const char *name)
Definition: commentscan.cpp:8299
initTriSingleQuoteBlock
static void initTriSingleQuoteBlock()
Definition: pyscanner.cpp:1746
YY_BUFFER_NORMAL
#define YY_BUFFER_NORMAL
Definition: pyscanner.cpp:255
YY_BUFFER_STATE
struct yy_buffer_state * YY_BUFFER_STATE
Definition: pyscanner.cpp:172
g_copyString
static QGString * g_copyString
Definition: pyscanner.cpp:1462
g_stringContext
static int g_stringContext
Definition: pyscanner.cpp:1461
Entry::docLine
int docLine
line number at which the documentation was found
Definition: entry.h:261
FALSE
const bool FALSE
Definition: qglobal.h:370
pyscannerYYlineno
int pyscannerYYlineno
Definition: pyscanner.cpp:365
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition: pyscanner.cpp:4618
Private
Definition: types.h:26
Entry::argList
ArgumentList * argList
member arguments as a list
Definition: entry.h:254
g_atomStart
static char g_atomStart
Definition: pyscanner.cpp:1468
EOB_ACT_CONTINUE_SCAN
#define EOB_ACT_CONTINUE_SCAN
Definition: pyscanner.cpp:179
Entry::addSubEntry
void addSubEntry(Entry *e)
Definition: entry.cpp:206
pyscannerYY_switch_to_buffer
void pyscannerYY_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: pyscanner.cpp:4290
Entry::name
QCString name
member name
Definition: entry.h:237
yy_buffer_state::yy_bs_lineno
int yy_bs_lineno
Definition: code.cpp:244
pyscannerYY_scan_string
YY_BUFFER_STATE pyscannerYY_scan_string(yyconst char *yy_str)
Definition: pyscanner.cpp:4574
QGString::resize
bool resize(uint newlen)
Definition: qgstring.cpp:96
pyscannerYY_scan_buffer
YY_BUFFER_STATE pyscannerYY_scan_buffer(char *base, yy_size_t size)
Definition: pyscanner.cpp:4537
pyscannerYYout
FILE * pyscannerYYout
Definition: pyscanner.cpp:359
QCString::left
QCString left(uint len) const
Definition: qcstring.cpp:213
PythonLanguageScanner::parseInput
void parseInput(const char *fileName, const char *fileBuf, Entry *root, bool sameTranslationUnit, QStrList &filesInSameTranslationUnit)
Definition: pyscanner.cpp:5019
yy_size_t
size_t yy_size_t
Definition: pyscanner.cpp:203
initEntry
static void initEntry()
Definition: pyscanner.cpp:1502
yyread
static int yyread(char *buf, int max_size)
Definition: pyscanner.cpp:1802
errno
int errno
Contains the last error code.
Definition: structcmd.h:53
pyscannerYYset_out
void pyscannerYYset_out(FILE *out_str)
Definition: pyscanner.cpp:4709
yy_cp
register char * yy_cp
Definition: pyscanner.cpp:2050
handleCommentBlock
static void handleCommentBlock(const QCString &doc, bool brief)
Definition: pyscanner.cpp:1676
if
if(!(yy_init))
Definition: pyscanner.cpp:2060
FunctionDec
#define FunctionDec
Definition: pyscanner.cpp:1854
QFile::setName
void setName(const QString &name)
Definition: qfile.cpp:167
PythonLanguageScanner::needsPreprocessing
bool needsPreprocessing(const QCString &extension)
Definition: pyscanner.cpp:5034
yy_hold_char
static char yy_hold_char
Definition: pyscanner.cpp:292
yy_buffer_state::yy_buf_size
yy_size_t yy_buf_size
Definition: code.cpp:218
initParser
static void initParser()
Definition: pyscanner.cpp:1491
SrcLangExt
SrcLangExt
Definition: types.h:41
ClassBody
#define ClassBody
Definition: pyscanner.cpp:1861
QCString::findRev
int findRev(char c, int index=-1, bool cs=TRUE) const
Definition: qcstring.cpp:95
Entry::parent
Entry * parent() const
Definition: entry.h:205
SingleQuoteString
#define SingleQuoteString
Definition: pyscanner.cpp:1865
pyscannerYYleng
int pyscannerYYleng
Definition: pyscanner.cpp:294
Normal
Definition: types.h:29
pyscannerYYlex_destroy
int pyscannerYYlex_destroy(void)
Definition: pyscanner.cpp:4758
inputFile
static QFile inputFile
Definition: pyscanner.cpp:1438
VariableEnd
#define VariableEnd
Definition: pyscanner.cpp:1863
IO_ReadOnly
#define IO_ReadOnly
Definition: qiodevice.h:61
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: pyscanner.cpp:2039
pyscannerYYset_debug
void pyscannerYYset_debug(int debug_flag)
Definition: pyscanner.cpp:4719
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition: pyscanner.cpp:378
addType
static void addType()
Definition: code.cpp:11175
parsePythonCode
void parsePythonCode(CodeOutputInterface &od, const char *, const QCString &s, bool exBlock, const char *exName, FileDef *fd, int startLine, int endLine, bool, MemberDef *, bool, Definition *searchCtx, bool collectXRefs)
Definition: pycode.cpp:4164
Config_getInt
#define Config_getInt(val)
Definition: config.cpp:661
util::size
decltype(auto) constexpr size(T &&obj)
ADL-aware version of std::size.
Definition: StdUtils.h:92
unput
#define unput(c)
Definition: pyscanner.cpp:199
Search
#define Search
Definition: pyscanner.cpp:1849
pyscannerYYtext
char * pyscannerYYtext
Definition: pyscanner.cpp:1370
Argument
This class contains the information about the argument of a function or template. ...
Definition: arguments.h:28
searchFoundDef
static void searchFoundDef()
Definition: pyscanner.cpp:1767
FunctionParams
#define FunctionParams
Definition: pyscanner.cpp:1855
previous
static Entry * previous
Definition: pyscanner.cpp:1444
yy_buffer_state::yy_at_bol
int yy_at_bol
Definition: code.cpp:242
YY_END_OF_BUFFER
#define YY_END_OF_BUFFER
Definition: pyscanner.cpp:386
searchFoundClass
static void searchFoundClass()
Definition: pyscanner.cpp:1786
stripQuotes
static QCString stripQuotes(const char *s)
Definition: commentscan.cpp:3626
QString::data
const char * data() const
Definition: qstring.h:542
QList::getLast
type * getLast() const
Definition: qlist.h:96
inputString
static const char * inputString
Definition: pyscanner.cpp:1436
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: pyscanner.cpp:163
groupEnterFile
void groupEnterFile(const char *fileName, int)
Definition: commentscan.cpp:8274
yy_base
static yyconst flex_int16_t yy_base[603]
Definition: pyscanner.cpp:595
yy_accept
static yyconst flex_int16_t yy_accept[497]
Definition: pyscanner.cpp:494
yyunput
static void yyunput(int c, char *buf_ptr)
yy_buffer_state::yy_bs_column
int yy_bs_column
Definition: code.cpp:245
YY_TRAILING_MASK
#define YY_TRAILING_MASK
Definition: pyscanner.cpp:1354
pyscannerYYget_leng
int pyscannerYYget_leng(void)
Definition: pyscanner.cpp:4674
PythonLanguageScanner::parseCode
void parseCode(CodeOutputInterface &codeOutIntf, const char *scopeName, const QCString &input, SrcLangExt lang, bool isExampleBlock, const char *exampleName=0, FileDef *fileDef=0, int startLine=-1, int endLine=-1, bool inlineFragment=FALSE, MemberDef *memberDef=0, bool showLineNumbers=TRUE, Definition *searchCtx=0, bool collectXrefs=TRUE)
Definition: pyscanner.cpp:5039
YY_END_OF_BUFFER_CHAR
#define YY_END_OF_BUFFER_CHAR
Definition: pyscanner.cpp:159
Entry::initializer
QGString initializer
initial value (for variables)
Definition: entry.h:257
input
static int input(void)
Definition: code.cpp:15695
pyscannerYY_create_buffer
YY_BUFFER_STATE pyscannerYY_create_buffer(FILE *file, int size)
Definition: pyscanner.cpp:4335
dumpTree.fileName
fileName
Definition: dumpTree.py:9
yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
Definition: pyscanner.cpp:4136
YY_NEW_FILE
#define YY_NEW_FILE
Definition: pyscanner.cpp:157
Entry::endBodyLine
int endBodyLine
line number where the definition ends
Definition: entry.h:277
g_atomEnd
static char g_atomEnd
Definition: pyscanner.cpp:1469
QFileInfo::dirPath
QString dirPath(bool absPath=FALSE) const
Definition: qfileinfo_unix.cpp:358
yy_lp
static int yy_lp
Definition: pyscanner.cpp:1350
YY_BREAK
#define YY_BREAK
Definition: pyscanner.cpp:2036
entry.h
pyscannerYYget_extra
YY_EXTRA_TYPE pyscannerYYget_extra(void)
Method
Definition: types.h:32
PythonLanguageScanner::parsePrototype
void parsePrototype(const char *text)
Definition: pyscanner.cpp:5060
pyscannerYYwrap
#define pyscannerYYwrap(n)
Definition: pyscanner.cpp:354
Entry::children
const QList< Entry > * children() const
Definition: entry.h:210
QCString::right
QCString right(uint len) const
Definition: qcstring.cpp:231
cet::n
std::void_t< T > n
Definition: metaprogramming.h:28
yy_fatal_error
static void yy_fatal_error(yyconst char msg[])
startCommentBlock
static void startCommentBlock(bool brief)
Definition: pyscanner.cpp:1653
yyterminate
#define yyterminate()
Definition: pyscanner.cpp:2001
pyscannerYY_flex_debug
int pyscannerYY_flex_debug
Definition: pyscanner.cpp:1346
a
const double a
Definition: gUpMuFluxGen.cxx:164
QFile::open
bool open(int)
Definition: qfile_unix.cpp:134
docBlockSpecial
static bool docBlockSpecial
Definition: pyscanner.cpp:1457
yy_init_globals
static int yy_init_globals(void)
Definition: pyscanner.cpp:4724
DoubleQuoteString
#define DoubleQuoteString
Definition: pyscanner.cpp:1866
cache_state.file
file
Definition: cache_state.py:421
pyscannerYY_load_buffer_state
static void pyscannerYY_load_buffer_state(void)
Definition: pyscanner.cpp:4321
pyscannerYYpush_buffer_state
void pyscannerYYpush_buffer_state(YY_BUFFER_STATE new_buffer)
Definition: pyscanner.cpp:4439
yyFileName
static QCString yyFileName
Definition: pyscanner.cpp:1447
Specifier
Specifier
Definition: types.h:29
YY_DECL
#define YY_DECL
Definition: pyscanner.cpp:2024
lineCount
static void lineCount()
Definition: pyscanner.cpp:1600
Entry::startLine
int startLine
start line of entry in the source
Definition: entry.h:283
QCString::prepend
QCString & prepend(const char *s)
Definition: qcstring.cpp:387
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: pyscanner.cpp:1369
parseMain
static void parseMain(const char *fileName, const char *fileBuf, Entry *rt)
Definition: pyscanner.cpp:4886
DBG_CTX
#define DBG_CTX(x)
Definition: pyscanner.cpp:1424
test.p
p
Definition: test.py:223
Entry::args
QCString args
member argument string
Definition: entry.h:252
yy_get_next_buffer
static int yy_get_next_buffer(void)
Definition: pyscanner.cpp:3999
YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER_LVALUE
Definition: pyscanner.cpp:289
util.h
A bunch of utility functions.
SearchMemVars
#define SearchMemVars
Definition: pyscanner.cpp:1850
QList::clear
void clear()
Definition: qlist.h:82
QCString::data
const char * data() const
Definition: qcstring.h:207
g_atomCount
static int g_atomCount
Definition: pyscanner.cpp:1470
EOB_ACT_LAST_MATCH
#define EOB_ACT_LAST_MATCH
Definition: pyscanner.cpp:181
current_root
static Entry * current_root
Definition: pyscanner.cpp:1442
yy_buffer_state::yy_ch_buf
char * yy_ch_buf
Definition: code.cpp:212
Entry::protection
Protection protection
class protection
Definition: entry.h:241
findPackageScope
static QCString findPackageScope(const char *fileName)
Definition: pyscanner.cpp:1591
ClassDec
#define ClassDec
Definition: pyscanner.cpp:1858
YY_CHAR
unsigned char YY_CHAR
Definition: code.cpp:357
FromMod
#define FromMod
Definition: pyscanner.cpp:1868
test_nxjs.indent
indent
Definition: test_nxjs.py:18
yy_bp
register char * yy_bp
Definition: pyscanner.cpp:2050
plot_model.stderr
stderr
Definition: plot_model.py:26
INITIAL
#define INITIAL
Definition: pyscanner.cpp:1848
initGroupInfo
void initGroupInfo(Entry *e)
Definition: commentscan.cpp:8412
warn
void warn(const char *file, int line, const char *fmt,...)
Definition: message.cpp:183
docBlockJavaStyle
static bool docBlockJavaStyle
Definition: pyscanner.cpp:1455
yy_buffer_state
Definition: code.cpp:208
g_specialBlock
static bool g_specialBlock
Definition: pyscanner.cpp:1460
pyscanFreeScanner
void pyscanFreeScanner()
Definition: pyscanner.cpp:5007
flex_int32_t
int flex_int32_t
Definition: code.cpp:72
initSpecialBlock
static void initSpecialBlock()
Definition: pyscanner.cpp:1757
pyscannerYYget_lineno
int pyscannerYYget_lineno(void)
Definition: pyscanner.cpp:4649
yy_buffer_state::yy_is_our_buffer
int yy_is_our_buffer
Definition: code.cpp:229
YY_START
#define YY_START
Definition: pyscanner.cpp:150
g_moduleScope
static QCString g_moduleScope
Definition: pyscanner.cpp:1474
YY_SC_TO_UI
#define YY_SC_TO_UI(c)
Definition: pyscanner.cpp:138
flex_int32_t
int flex_int32_t
Definition: pyscanner.cpp:72
yy_state_ptr
static yy_state_type * yy_state_ptr
Definition: pyscanner.cpp:1348
keras_to_tensorflow.int
int
Definition: keras_to_tensorflow.py:69
removeRedundantWhiteSpace
QCString removeRedundantWhiteSpace(const QCString &s)
Definition: util.cpp:1655
yy_nxt
static yyconst flex_int16_t yy_nxt[2725]
Definition: pyscanner.cpp:737
make_input_cov.input_file
input_file
Definition: make_input_cov.py:11
yyLineNr
static int yyLineNr
Definition: pyscanner.cpp:1446
QCString::mid
QCString mid(uint index, uint len=0xffffffff) const
Definition: qcstring.cpp:246
QFile
The QFile class is an I/O device that operates on files.
Definition: qfile.h:50
newFunction
static void newFunction()
Definition: pyscanner.cpp:1536
Entry::doc
QCString doc
documentation block (partly parsed)
Definition: entry.h:260
Entry::virt
Specifier virt
virtualness of the entry
Definition: entry.h:251
parseCommentBlock
bool parseCommentBlock(ParserInterface *parser, Entry *curEntry, const QCString &comment, const QCString &fileName, int &lineNr, bool isBrief, bool isAutoBriefOn, bool isInbody, Protection &prot, int &position, bool &newEntryNeeded)
Definition: commentscan.cpp:8149
pyscannerYY_init_buffer
static void pyscannerYY_init_buffer(YY_BUFFER_STATE b, FILE *file)
Definition: pyscanner.cpp:4382
SpecialComment
#define SpecialComment
Definition: pyscanner.cpp:1853
initTriDoubleQuoteBlock
static void initTriDoubleQuoteBlock()
Definition: pyscanner.cpp:1735
yy_state_buf
static yy_state_type * yy_state_buf
Definition: pyscanner.cpp:1348
pyscannerYYensure_buffer_stack
static void pyscannerYYensure_buffer_stack(void)
Definition: pyscanner.cpp:4488
yytext_ptr
#define yytext_ptr
Definition: pyscanner.cpp:368
findPackageScopeFromPath
static QCString findPackageScopeFromPath(const QCString &path)
Definition: pyscanner.cpp:1565
docBlock
static QCString docBlock
Definition: pyscanner.cpp:1453
pyscannerYYalloc
void * pyscannerYYalloc(yy_size_t)
Definition: pyscanner.cpp:4806
pyscannerYY_flush_buffer
void pyscannerYY_flush_buffer(YY_BUFFER_STATE b)
Definition: pyscanner.cpp:4410
yy_state_type
int yy_state_type
Definition: pyscanner.cpp:361
yy_buffer_stack_max
static size_t yy_buffer_stack_max
Definition: pyscanner.cpp:273
pyscannerYYget_debug
int pyscannerYYget_debug(void)
Definition: pyscanner.cpp:4714
g_doubleQuote
static bool g_doubleQuote
Definition: pyscanner.cpp:1459
pyscannerYYset_lineno
void pyscannerYYset_lineno(int line_number)
Definition: pyscanner.cpp:4692
yy_c_buf_p
static char * yy_c_buf_p
Definition: pyscanner.cpp:297
yy_def
static yyconst flex_int16_t yy_def[603]
Definition: pyscanner.cpp:666
yy_meta
static yyconst flex_int32_t yy_meta[53]
Definition: pyscanner.cpp:585
TripleComment
#define TripleComment
Definition: pyscanner.cpp:1852
docBlockContext
static int docBlockContext
Definition: pyscanner.cpp:1452
Argument::name
QCString name
Definition: arguments.h:69
pyscannerYY_delete_buffer
void pyscannerYY_delete_buffer(YY_BUFFER_STATE b)
Definition: pyscanner.cpp:4363
parseCompounds
static void parseCompounds(Entry *rt)
Definition: pyscanner.cpp:4836
current
static Entry * current
Definition: pyscanner.cpp:1443
ClassInheritance
#define ClassInheritance
Definition: pyscanner.cpp:1859
Entry::fileName
QCString fileName
file this entry was extracted from
Definition: entry.h:282
doc
QCString doc
Definition: vhdljjparser.cpp:77
groupLeaveCompound
void groupLeaveCompound(const char *, int, const char *)
Definition: commentscan.cpp:8321
g_thisParser
static ParserInterface * g_thisParser
Definition: pyscanner.cpp:1435
BEGIN
#define BEGIN
Definition: pyscanner.cpp:144
groupLeaveFile
void groupLeaveFile(const char *fileName, int line)
Definition: commentscan.cpp:8284
b
static bool * b
Definition: config.cpp:1043
g_braceCount
static int g_braceCount
Definition: pyscanner.cpp:1480
MethodTypes
MethodTypes
Definition: types.h:32
Protection
Protection
Definition: types.h:26
Entry::docFile
QCString docFile
file in which the documentation was found
Definition: entry.h:262
pyscannerYYlex
int pyscannerYYlex(void)
yy_act
register int yy_act
Definition: pyscanner.cpp:2051
Entry::mtype
MethodTypes mtype
signal, slot, (dcop) method, or property?
Definition: entry.h:242
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: pyscanner.cpp:282
yy_did_buffer_switch_on_eof
static int yy_did_buffer_switch_on_eof
Definition: pyscanner.cpp:304
yy_buffer_state::yy_is_interactive
int yy_is_interactive
Definition: code.cpp:236
g_search_count
static int g_search_count
Definition: pyscanner.cpp:1486
virt
static Specifier virt
Definition: pyscanner.cpp:1450
pyscannerYYget_text
char * pyscannerYYget_text(void)
Definition: pyscanner.cpp:4683
bodyEntry
static Entry * bodyEntry
Definition: pyscanner.cpp:1445
FromModItem
#define FromModItem
Definition: pyscanner.cpp:1869
ClassCaptureIndent
#define ClassCaptureIndent
Definition: pyscanner.cpp:1860
g_start_init
static bool g_start_init
Definition: pyscanner.cpp:1485
g_indent
static int g_indent
Definition: pyscanner.cpp:1463
pyscannerYYget_in
FILE * pyscannerYYget_in(void)
Definition: pyscanner.cpp:4658
flex_int16_t
short int flex_int16_t
Definition: pyscanner.cpp:71
baseName
static QCString baseName
Definition: scanner.cpp:10890
gstat
static bool gstat
Definition: pyscanner.cpp:1449
g_packageNameCache
static QDict< QCString > g_packageNameCache(257)
yy_chk
static yyconst flex_int16_t yy_chk[2725]
Definition: pyscanner.cpp:1041
flex_uint32_t
unsigned int flex_uint32_t
Definition: pyscanner.cpp:75
yy_get_previous_state
static yy_state_type yy_get_previous_state(void)
Definition: pyscanner.cpp:4104
g_lexInit
static bool g_lexInit
Definition: pyscanner.cpp:1482
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition: pyscanner.cpp:154
QFileInfo
The QFileInfo class provides system-independent file information.
Definition: qfileinfo.h:51
yy_looking_for_trail_begin
static int yy_looking_for_trail_begin
Definition: pyscanner.cpp:1351
newVariable
static void newVariable()
Definition: pyscanner.cpp:1523
Entry::lang
SrcLangExt lang
programming language in which this entry was found
Definition: entry.h:286
g_curIndent
static int g_curIndent
Definition: pyscanner.cpp:1464
QFile::close
void close()
Definition: qfile_unix.cpp:614
BaseInfo
Definition: entry.h:37
g_defVal
static QCString g_defVal
Definition: pyscanner.cpp:1479
ECHO
#define ECHO
Definition: pyscanner.cpp:1957
yy_start
static int yy_start
Definition: pyscanner.cpp:299
uint
unsigned uint
Definition: qglobal.h:351
incLineNr
static void incLineNr()
Definition: pyscanner.cpp:1609
util::quantities::bytes
byte bytes
Alias for common language habits.
Definition: datasize.h:101
yy_full_state
static int * yy_full_state
Definition: pyscanner.cpp:1353
Property
Definition: types.h:32
yy_size_t
size_t yy_size_t
Definition: code.cpp:203
commentscan.h
Interface for the comment block parser.
yy_trans_info
Definition: code.cpp:389
yy_buffer_state::yy_buffer_status
int yy_buffer_status
Definition: code.cpp:252
s
static QCString * s
Definition: config.cpp:1042
TRUE
const bool TRUE
Definition: qglobal.h:371
newEntry
static void newEntry()
Definition: pyscanner.cpp:1515
collectXRefs
bool collectXRefs
Definition: tclscanner.cpp:1153
Entry::extends
QList< BaseInfo > * extends
list of base classes
Definition: entry.h:279
substitute
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition: util.cpp:5088
YY_INPUT
#define YY_INPUT(buf, result, max_size)
Definition: pyscanner.cpp:1800
QCString::append
QCString & append(const char *s)
Definition: qcstring.cpp:383
pyscannerYYfree
void pyscannerYYfree(void *)
Definition: pyscanner.cpp:4823
Entry::type
QCString type
member type
Definition: entry.h:236
flex_uint8_t
unsigned char flex_uint8_t
Definition: pyscanner.cpp:73
QFileInfo::exists
bool exists() const
Definition: qfileinfo.cpp:265
YY_CHAR
unsigned char YY_CHAR
Definition: pyscanner.cpp:357
Entry::section
int section
entry type (see Sections);
Definition: entry.h:235
Entry::bodyLine
int bodyLine
line number of the definition in the source
Definition: entry.h:276
Entry::briefFile
QCString briefFile
file in which the brief desc. was found
Definition: entry.h:265
YY_STATE_BUF_SIZE
#define YY_STATE_BUF_SIZE
Definition: pyscanner.cpp:168
pyscannerYYget_out
FILE * pyscannerYYget_out(void)
Definition: pyscanner.cpp:4666
Generated by   doxygen 1.8.11