00001 00002 #line 3 "<stdout>" 00003 00004 #define YY_INT_ALIGNED short int 00005 00006 /* A lexical scanner generated by flex */ 00007 00008 #define FLEX_SCANNER 00009 #define YY_FLEX_MAJOR_VERSION 2 00010 #define YY_FLEX_MINOR_VERSION 5 00011 #define YY_FLEX_SUBMINOR_VERSION 33 00012 #if YY_FLEX_SUBMINOR_VERSION > 0 00013 #define FLEX_BETA 00014 #endif 00015 00016 /* First, we deal with platform-specific or compiler-specific issues. */ 00017 00018 /* begin standard C headers. */ 00019 #include <stdio.h> 00020 #include <string.h> 00021 #include <errno.h> 00022 #include <stdlib.h> 00023 00024 /* end standard C headers. */ 00025 00026 /* flex integer type definitions */ 00027 00028 #ifndef FLEXINT_H 00029 #define FLEXINT_H 00030 00031 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ 00032 00033 #if __STDC_VERSION__ >= 199901L 00034 00035 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, 00036 * if you want the limit (max/min) macros for int types. 00037 */ 00038 #ifndef __STDC_LIMIT_MACROS 00039 #define __STDC_LIMIT_MACROS 1 00040 #endif 00041 00042 #include <inttypes.h> 00043 typedef int8_t flex_int8_t; 00044 typedef uint8_t flex_uint8_t; 00045 typedef int16_t flex_int16_t; 00046 typedef uint16_t flex_uint16_t; 00047 typedef int32_t flex_int32_t; 00048 typedef uint32_t flex_uint32_t; 00049 #else 00050 typedef signed char flex_int8_t; 00051 typedef short int flex_int16_t; 00052 typedef int flex_int32_t; 00053 typedef unsigned char flex_uint8_t; 00054 typedef unsigned short int flex_uint16_t; 00055 typedef unsigned int flex_uint32_t; 00056 #endif /* ! C99 */ 00057 00058 /* Limits of integral types. */ 00059 #ifndef INT8_MIN 00060 #define INT8_MIN (-128) 00061 #endif 00062 #ifndef INT16_MIN 00063 #define INT16_MIN (-32767-1) 00064 #endif 00065 #ifndef INT32_MIN 00066 #define INT32_MIN (-2147483647-1) 00067 #endif 00068 #ifndef INT8_MAX 00069 #define INT8_MAX (127) 00070 #endif 00071 #ifndef INT16_MAX 00072 #define INT16_MAX (32767) 00073 #endif 00074 #ifndef INT32_MAX 00075 #define INT32_MAX (2147483647) 00076 #endif 00077 #ifndef UINT8_MAX 00078 #define UINT8_MAX (255U) 00079 #endif 00080 #ifndef UINT16_MAX 00081 #define UINT16_MAX (65535U) 00082 #endif 00083 #ifndef UINT32_MAX 00084 #define UINT32_MAX (4294967295U) 00085 #endif 00086 00087 #endif /* ! FLEXINT_H */ 00088 00089 #ifdef __cplusplus 00090 00091 /* The "const" storage-class-modifier is valid. */ 00092 #define YY_USE_CONST 00093 00094 #else /* ! __cplusplus */ 00095 00096 #if __STDC__ 00097 00098 #define YY_USE_CONST 00099 00100 #endif /* __STDC__ */ 00101 #endif /* ! __cplusplus */ 00102 00103 #ifdef YY_USE_CONST 00104 #define yyconst const 00105 #else 00106 #define yyconst 00107 #endif 00108 00109 /* Returned upon end-of-file. */ 00110 #define YY_NULL 0 00111 00112 /* Promotes a possibly negative, possibly signed char to an unsigned 00113 * integer for use as an array index. If the signed char is negative, 00114 * we want to instead treat it as an 8-bit unsigned char, hence the 00115 * double cast. 00116 */ 00117 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 00118 00119 /* Enter a start condition. This macro really ought to take a parameter, 00120 * but we do it the disgusting crufty way forced on us by the ()-less 00121 * definition of BEGIN. 00122 */ 00123 #define BEGIN (yy_start) = 1 + 2 * 00124 00125 /* Translate the current start state into a value that can be later handed 00126 * to BEGIN to return to the state. The YYSTATE alias is for lex 00127 * compatibility. 00128 */ 00129 #define YY_START (((yy_start) - 1) / 2) 00130 #define YYSTATE YY_START 00131 00132 /* Action number for EOF rule of a given start state. */ 00133 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 00134 00135 /* Special action meaning "start processing a new file". */ 00136 #define YY_NEW_FILE pyscanYYrestart(pyscanYYin ) 00137 00138 #define YY_END_OF_BUFFER_CHAR 0 00139 00140 /* Size of default input buffer. */ 00141 #ifndef YY_BUF_SIZE 00142 #define YY_BUF_SIZE 262144 00143 #endif 00144 00145 /* The state buf must be large enough to hold one state per character in the main buffer. 00146 */ 00147 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 00148 00149 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 00150 #define YY_TYPEDEF_YY_BUFFER_STATE 00151 typedef struct yy_buffer_state *YY_BUFFER_STATE; 00152 #endif 00153 00154 extern int pyscanYYleng; 00155 00156 extern FILE *pyscanYYin, *pyscanYYout; 00157 00158 #define EOB_ACT_CONTINUE_SCAN 0 00159 #define EOB_ACT_END_OF_FILE 1 00160 #define EOB_ACT_LAST_MATCH 2 00161 00162 #define YY_LESS_LINENO(n) 00163 00164 /* Return all but the first "n" matched characters back to the input stream. */ 00165 #define yyless(n) \ 00166 do \ 00167 { \ 00168 /* Undo effects of setting up pyscanYYtext. */ \ 00169 int yyless_macro_arg = (n); \ 00170 YY_LESS_LINENO(yyless_macro_arg);\ 00171 *yy_cp = (yy_hold_char); \ 00172 YY_RESTORE_YY_MORE_OFFSET \ 00173 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 00174 YY_DO_BEFORE_ACTION; /* set up pyscanYYtext again */ \ 00175 } \ 00176 while ( 0 ) 00177 00178 #define unput(c) yyunput( c, (yytext_ptr) ) 00179 00180 /* The following is because we cannot portably get our hands on size_t 00181 * (without autoconf's help, which isn't available because we want 00182 * flex-generated scanners to compile on their own). 00183 */ 00184 00185 #ifndef YY_TYPEDEF_YY_SIZE_T 00186 #define YY_TYPEDEF_YY_SIZE_T 00187 typedef unsigned int yy_size_t; 00188 #endif 00189 00190 #ifndef YY_STRUCT_YY_BUFFER_STATE 00191 #define YY_STRUCT_YY_BUFFER_STATE 00192 struct yy_buffer_state 00193 { 00194 FILE *yy_input_file; 00195 00196 char *yy_ch_buf; /* input buffer */ 00197 char *yy_buf_pos; /* current position in input buffer */ 00198 00199 /* Size of input buffer in bytes, not including room for EOB 00200 * characters. 00201 */ 00202 yy_size_t yy_buf_size; 00203 00204 /* Number of characters read into yy_ch_buf, not including EOB 00205 * characters. 00206 */ 00207 int yy_n_chars; 00208 00209 /* Whether we "own" the buffer - i.e., we know we created it, 00210 * and can realloc() it to grow it, and should free() it to 00211 * delete it. 00212 */ 00213 int yy_is_our_buffer; 00214 00215 /* Whether this is an "interactive" input source; if so, and 00216 * if we're using stdio for input, then we want to use getc() 00217 * instead of fread(), to make sure we stop fetching input after 00218 * each newline. 00219 */ 00220 int yy_is_interactive; 00221 00222 /* Whether we're considered to be at the beginning of a line. 00223 * If so, '^' rules will be active on the next match, otherwise 00224 * not. 00225 */ 00226 int yy_at_bol; 00227 00228 int yy_bs_lineno; 00229 int yy_bs_column; 00231 /* Whether to try to fill the input buffer when we reach the 00232 * end of it. 00233 */ 00234 int yy_fill_buffer; 00235 00236 int yy_buffer_status; 00237 00238 #define YY_BUFFER_NEW 0 00239 #define YY_BUFFER_NORMAL 1 00240 /* When an EOF's been seen but there's still some text to process 00241 * then we mark the buffer as YY_EOF_PENDING, to indicate that we 00242 * shouldn't try reading from the input source any more. We might 00243 * still have a bunch of tokens to match, though, because of 00244 * possible backing-up. 00245 * 00246 * When we actually see the EOF, we change the status to "new" 00247 * (via pyscanYYrestart()), so that the user can continue scanning by 00248 * just pointing pyscanYYin at a new input file. 00249 */ 00250 #define YY_BUFFER_EOF_PENDING 2 00251 00252 }; 00253 #endif /* !YY_STRUCT_YY_BUFFER_STATE */ 00254 00255 /* Stack of input buffers. */ 00256 static size_t yy_buffer_stack_top = 0; 00257 static size_t yy_buffer_stack_max = 0; 00258 static YY_BUFFER_STATE * yy_buffer_stack = 0; 00260 /* We provide macros for accessing buffer states in case in the 00261 * future we want to put the buffer states in a more general 00262 * "scanner state". 00263 * 00264 * Returns the top of the stack, or NULL. 00265 */ 00266 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 00267 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 00268 : NULL) 00269 00270 /* Same as previous macro, but useful when we know that the buffer stack is not 00271 * NULL or when we need an lvalue. For internal use only. 00272 */ 00273 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 00274 00275 /* yy_hold_char holds the character lost when pyscanYYtext is formed. */ 00276 static char yy_hold_char; 00277 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 00278 int pyscanYYleng; 00279 00280 /* Points to current character in buffer. */ 00281 static char *yy_c_buf_p = (char *) 0; 00282 static int yy_init = 0; /* whether we need to initialize */ 00283 static int yy_start = 0; /* start state number */ 00284 00285 /* Flag which is used to allow pyscanYYwrap()'s to do buffer switches 00286 * instead of setting up a fresh pyscanYYin. A bit of a hack ... 00287 */ 00288 static int yy_did_buffer_switch_on_eof; 00289 00290 void pyscanYYrestart (FILE *input_file ); 00291 void pyscanYY_switch_to_buffer (YY_BUFFER_STATE new_buffer ); 00292 YY_BUFFER_STATE pyscanYY_create_buffer (FILE *file,int size ); 00293 void pyscanYY_delete_buffer (YY_BUFFER_STATE b ); 00294 void pyscanYY_flush_buffer (YY_BUFFER_STATE b ); 00295 void pyscanYYpush_buffer_state (YY_BUFFER_STATE new_buffer ); 00296 void pyscanYYpop_buffer_state (void ); 00297 00298 static void pyscanYYensure_buffer_stack (void ); 00299 static void pyscanYY_load_buffer_state (void ); 00300 static void pyscanYY_init_buffer (YY_BUFFER_STATE b,FILE *file ); 00301 00302 #define YY_FLUSH_BUFFER pyscanYY_flush_buffer(YY_CURRENT_BUFFER ) 00303 00304 YY_BUFFER_STATE pyscanYY_scan_buffer (char *base,yy_size_t size ); 00305 YY_BUFFER_STATE pyscanYY_scan_string (yyconst char *yy_str ); 00306 YY_BUFFER_STATE pyscanYY_scan_bytes (yyconst char *bytes,int len ); 00307 00308 void *pyscanYYalloc (yy_size_t ); 00309 void *pyscanYYrealloc (void *,yy_size_t ); 00310 void pyscanYYfree (void * ); 00311 00312 #define yy_new_buffer pyscanYY_create_buffer 00313 00314 #define yy_set_interactive(is_interactive) \ 00315 { \ 00316 if ( ! YY_CURRENT_BUFFER ){ \ 00317 pyscanYYensure_buffer_stack (); \ 00318 YY_CURRENT_BUFFER_LVALUE = \ 00319 pyscanYY_create_buffer(pyscanYYin,YY_BUF_SIZE ); \ 00320 } \ 00321 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 00322 } 00323 00324 #define yy_set_bol(at_bol) \ 00325 { \ 00326 if ( ! YY_CURRENT_BUFFER ){\ 00327 pyscanYYensure_buffer_stack (); \ 00328 YY_CURRENT_BUFFER_LVALUE = \ 00329 pyscanYY_create_buffer(pyscanYYin,YY_BUF_SIZE ); \ 00330 } \ 00331 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 00332 } 00333 00334 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 00335 00336 /* Begin user sect3 */ 00337 00338 #define pyscanYYwrap(n) 1 00339 #define YY_SKIP_YYWRAP 00340 00341 typedef unsigned char YY_CHAR; 00342 00343 FILE *pyscanYYin = (FILE *) 0, *pyscanYYout = (FILE *) 0; 00344 00345 typedef int yy_state_type; 00346 00347 extern int pyscanYYlineno; 00348 00349 int pyscanYYlineno = 1; 00350 00351 extern char *pyscanYYtext; 00352 #define yytext_ptr pyscanYYtext 00353 00354 static yy_state_type yy_get_previous_state (void ); 00355 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); 00356 static int yy_get_next_buffer (void ); 00357 static void yy_fatal_error (yyconst char msg[] ); 00358 00359 /* Done after the current pattern has been matched and before the 00360 * corresponding action - sets up pyscanYYtext. 00361 */ 00362 #define YY_DO_BEFORE_ACTION \ 00363 (yytext_ptr) = yy_bp; \ 00364 pyscanYYleng = (size_t) (yy_cp - yy_bp); \ 00365 (yy_hold_char) = *yy_cp; \ 00366 *yy_cp = '\0'; \ 00367 (yy_c_buf_p) = yy_cp; 00368 00369 #define YY_NUM_RULES 146 00370 #define YY_END_OF_BUFFER 147 00371 /* This struct is not used in this scanner, 00372 but its presence is necessary. */ 00373 struct yy_trans_info 00374 { 00375 flex_int32_t yy_verify; 00376 flex_int32_t yy_nxt; 00377 }; 00378 static yyconst flex_int16_t yy_acclist[701] = 00379 { 0, 00380 16476,16476, 94, 94, 23, 23, 28, 28, 32, 32, 00381 147, 145, 146, 144, 146, 15, 145, 146, 15, 145, 00382 146, 16, 144, 146, 11, 15, 145, 146, 15, 145, 00383 146, 10, 15, 145, 146, 13, 15, 145, 146, 13, 00384 15, 145, 146, 13, 15, 145, 146, 13, 15, 145, 00385 146, 13, 15, 145, 146, 14, 15, 145, 146, 15, 00386 145, 146, 13, 15, 145, 146,16393, 13, 15, 145, 00387 146,16393, 13, 15, 145, 146,16393, 13, 15, 145, 00388 146,16393, 13, 15, 145, 146,16393, 42, 145, 146, 00389 42, 145, 146, 41, 144, 146, 40, 42, 145, 146, 00390 00391 42, 145, 146, 39, 42, 145, 146, 42, 145, 146, 00392 42, 145, 146, 42, 145, 146, 119, 121, 145, 146, 00393 121, 145, 146, 120, 144, 146, 121, 145, 146, 121, 00394 145, 146, 118, 121, 145, 146, 124, 126, 145, 146, 00395 125, 144, 146, 126, 145, 146, 124, 126, 145, 146, 00396 122, 126, 145, 146, 145, 146, 59, 145, 146, 58, 00397 145, 146, 57, 145, 146, 66, 145, 146, 60, 145, 00398 146, 66, 145, 146, 63, 145, 146, 60, 66, 145, 00399 146, 64, 145, 146, 62, 66, 145, 146, 61, 66, 00400 145, 146, 49, 53, 145, 146, 53, 145, 146, 52, 00401 00402 144, 146,16427, 48, 53, 145, 146, 51, 53, 145, 00403 146, 47, 53, 145, 146, 46, 53, 145, 146, 51, 00404 53, 145, 146, 70, 145, 146, 71, 144, 146, 67, 00405 70, 145, 146, 69, 70, 145, 146, 68, 70, 145, 00406 146, 84, 145, 146, 85, 145, 146, 85, 145, 146, 00407 86, 145, 146, 87, 145, 146, 145, 146, 88, 144, 00408 146, 8284, 145, 146, 145, 146, 145, 146, 91, 145, 00409 146, 78, 81, 145, 146, 81, 145, 146, 79, 144, 00410 146, 77, 81, 145, 146, 81, 145, 146, 76, 81, 00411 145, 146, 75, 81, 145, 146, 106, 145, 146, 94, 00412 00413 106, 145, 146, 107, 144, 146, 98, 106, 145, 146, 00414 104, 106, 145, 146, 97, 106, 145, 146, 101, 106, 00415 145, 146, 95, 106, 145, 146, 95, 106, 145, 146, 00416 93, 106, 145, 146, 105, 106, 145, 146, 105, 106, 00417 145, 146, 105, 106, 145, 146, 102, 106, 145, 146, 00418 105, 106, 145, 146, 103, 106, 145, 146, 115, 145, 00419 146, 114, 144, 146, 112, 145, 146, 113, 144, 146, 00420 110, 112, 145, 146, 108, 112, 145, 146, 109, 112, 00421 145, 146, 111, 112, 145, 146, 131, 132, 145, 146, 00422 132, 145, 146, 130, 132, 145, 146, 132, 145, 146, 00423 00424 137, 138, 145, 146, 136, 138, 145, 146, 138, 145, 00425 146, 138, 145, 146, 141, 143, 145, 146, 141, 142, 00426 144, 146, 141, 143, 145, 146, 141, 143, 145, 146, 00427 143, 145, 146, 24, 145, 146, 23, 24, 145, 146, 00428 22, 144, 146, 20, 24, 145, 146, 20, 24, 145, 00429 146, 29, 145, 146, 28, 29, 145, 146, 27, 144, 00430 146, 25, 29, 145, 146, 26, 29, 145, 146, 33, 00431 145, 146, 32, 33, 145, 146, 31, 144, 146, 30, 00432 33, 145, 146, 16, 12, 13, 13, 13, 13, 13, 00433 14,16393,16393,16393,16393,16393, 13,16393, 13,16393, 00434 00435 13,16393, 13,16393, 13,16393, 38, 119, 118, 124, 00436 123, 124, 122, 122, 59, 58, 57, 60, 65, 64, 00437 61, 49,16427, 51, 46, 45, 50, 51, 51, 84, 00438 85, 87, 88, 91, 78, 80, 75, 74, 94, 104, 00439 95, 95, 95, 105, 98, 97, 105, 111, 131, 128, 00440 128, 127, 137, 134, 134, 133, 141, 141, 141, 23, 00441 20, 20, 28, 26, 32, 30, 17, 12, 18, 13, 00442 13, 13, 13,16393,16393,16393,16393,16393, 19, 8201, 00443 13,16393, 13,16393, 13,16393, 13,16393, 35, 38, 00444 36, 37, 116, 117, 65, 44, 8235, 54, 55, 50, 00445 00446 50, 51, 51, 56, 56, 87, 89, 90, 73, 72, 00447 82, 80, 83, 99, 100, 96, 95, 95, 129, 135, 00448 139, 140, 20, 20, 30, 17, 18, 13, 2, 13, 00449 13,16393,16393,16393,16393, 13,16393, 1, 2, 13, 00450 16393, 13,16393, 35, 36, 116, 117, 54, 55, 50, 00451 87, 89, 90, 82, 83, 99, 100, 96, 95, 139, 00452 140, 20, 20, 30, 13, 6, 13,16393, 1,16393, 00453 16393, 13,16393, 5, 6, 13,16393, 96, 20, 4, 00454 13,16393, 5,16393, 3, 4, 13,16393,16418, 20, 00455 21, 8, 3,16393, 7, 8,16418, 8226, 21, 7 00456 00457 } ; 00458 00459 static yyconst flex_int16_t yy_accept[438] = 00460 { 0, 00461 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00462 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00463 1, 1, 1, 1, 1, 2, 3, 3, 3, 4, 00464 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 00465 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 00466 19, 22, 25, 29, 32, 36, 40, 44, 48, 52, 00467 56, 60, 63, 68, 73, 78, 83, 88, 91, 94, 00468 97, 101, 104, 108, 111, 114, 117, 121, 124, 127, 00469 130, 133, 137, 141, 144, 147, 151, 155, 157, 160, 00470 163, 166, 169, 172, 175, 178, 182, 185, 189, 193, 00471 00472 197, 200, 204, 208, 212, 216, 220, 224, 227, 230, 00473 234, 238, 242, 245, 248, 251, 254, 257, 259, 262, 00474 265, 267, 269, 272, 276, 279, 282, 286, 289, 293, 00475 297, 300, 304, 307, 311, 315, 319, 323, 327, 331, 00476 335, 339, 343, 347, 351, 355, 359, 362, 365, 368, 00477 371, 375, 379, 383, 387, 391, 394, 398, 401, 405, 00478 409, 412, 415, 419, 423, 427, 431, 434, 437, 441, 00479 444, 448, 452, 455, 459, 462, 466, 470, 473, 477, 00480 480, 484, 484, 484, 485, 485, 486, 486, 487, 488, 00481 489, 490, 491, 492, 492, 493, 494, 495, 496, 497, 00482 00483 497, 497, 499, 499, 501, 503, 505, 507, 507, 507, 00484 507, 508, 508, 508, 508, 508, 508, 509, 509, 509, 00485 510, 511, 511, 512, 513, 514, 515, 515, 516, 517, 00486 518, 519, 519, 520, 521, 522, 523, 524, 524, 524, 00487 524, 525, 525, 526, 527, 527, 529, 530, 531, 532, 00488 532, 533, 533, 534, 534, 534, 535, 536, 536, 536, 00489 536, 536, 536, 537, 537, 538, 539, 540, 540, 541, 00490 541, 541, 542, 543, 544, 544, 545, 546, 547, 548, 00491 549, 550, 550, 551, 552, 553, 554, 554, 555, 556, 00492 557, 558, 558, 559, 560, 561, 561, 561, 562, 563, 00493 00494 564, 565, 566, 566, 566, 567, 568, 569, 570, 571, 00495 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 00496 583, 585, 587, 589, 590, 591, 592, 592, 593, 594, 00497 595, 596, 597, 598, 598, 599, 600, 601, 601, 603, 00498 605, 606, 607, 608, 609, 610, 611, 611, 612, 613, 00499 614, 615, 616, 617, 618, 619, 620, 620, 621, 621, 00500 622, 623, 623, 624, 625, 625, 626, 627, 628, 629, 00501 630, 631, 632, 633, 634, 635, 636, 638, 640, 642, 00502 644, 645, 646, 646, 647, 648, 649, 650, 651, 652, 00503 653, 654, 655, 656, 657, 658, 658, 659, 660, 661, 00504 00505 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 00506 672, 674, 676, 678, 678, 678, 679, 680, 681, 682, 00507 683, 684, 685, 687, 689, 690, 692, 693, 694, 695, 00508 697, 697, 698, 699, 700, 701, 701 00509 } ; 00510 00511 static yyconst flex_int32_t yy_ec[256] = 00512 { 0, 00513 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 00514 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00515 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00516 1, 2, 4, 5, 6, 1, 7, 7, 8, 9, 00517 10, 11, 12, 13, 12, 14, 7, 15, 16, 16, 00518 16, 16, 16, 16, 16, 17, 17, 18, 7, 7, 00519 19, 7, 1, 1, 20, 20, 20, 20, 21, 20, 00520 22, 22, 22, 23, 22, 24, 22, 22, 22, 22, 00521 22, 25, 22, 22, 26, 22, 22, 27, 22, 22, 00522 28, 29, 30, 1, 31, 7, 32, 20, 33, 34, 00523 00524 35, 36, 22, 22, 37, 23, 22, 38, 39, 22, 00525 40, 41, 22, 42, 43, 44, 45, 22, 22, 27, 00526 22, 22, 46, 7, 30, 7, 1, 1, 1, 1, 00527 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00528 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00529 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00530 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00531 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00532 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00533 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00534 00535 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00536 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00537 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00538 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00539 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00540 1, 1, 1, 1, 1 00541 } ; 00542 00543 static yyconst flex_int32_t yy_meta[47] = 00544 { 0, 00545 1, 2, 3, 1, 4, 5, 1, 4, 1, 1, 00546 1, 1, 1, 6, 7, 7, 7, 1, 8, 9, 00547 9, 10, 10, 10, 10, 10, 10, 1, 11, 1, 00548 10, 9, 9, 9, 9, 9, 10, 10, 10, 10, 00549 10, 10, 10, 10, 10, 1 00550 } ; 00551 00552 static yyconst flex_int16_t yy_base[516] = 00553 { 0, 00554 1533, 1523, 0, 46, 91, 98, 1522, 1513, 105, 109, 00555 92, 113, 141, 0, 187, 0, 118, 125, 231, 233, 00556 246, 0, 292, 0, 338, 346, 350, 357, 365, 0, 00557 1512, 1507, 411, 0, 455, 456, 462, 463, 469, 470, 00558 499, 0, 545, 0, 591, 0, 1506, 1655, 1655, 1655, 00559 103, 1500, 1488, 0, 1474, 0, 1439, 1440, 1432, 1434, 00560 636, 1466, 116, 637, 460, 638, 639, 1655, 123, 1655, 00561 1459, 0, 1455, 1427, 134, 1455, 0, 1655, 1655, 1452, 00562 1425, 1420, 0, 233, 1655, 355, 1411, 478, 1655, 1655, 00563 0, 1655, 480, 0, 1655, 1655, 1413, 1655, 0, 0, 00564 00565 1655, 487, 1409, 0, 1405, 641, 1406, 1655, 1655, 1655, 00566 1655, 1655, 0, 1400, 1655, 1655, 1379, 135, 1655, 1655, 00567 1375, 1366, 235, 0, 488, 1354, 1346, 0, 1342, 643, 00568 1655, 1347, 1655, 1343, 0, 1330, 1655, 667, 635, 1655, 00569 0, 337, 660, 1655, 671, 1655, 1655, 1655, 1655, 1655, 00570 1655, 1655, 1655, 0, 0, 1328, 1655, 650, 0, 1655, 00571 1322, 652, 1300, 1299, 1319, 1312, 656, 1655, 1315, 1655, 00572 467, 672, 1655, 1314, 1655, 1655, 0, 1655, 1313, 1655, 00573 474, 661, 0, 1303, 1280, 0, 1276, 0, 1232, 1227, 00574 1218, 1213, 686, 1238, 658, 687, 691, 685, 693, 0, 00575 00576 695, 696, 0, 697, 698, 699, 705, 729, 0, 1230, 00577 0, 1225, 1190, 731, 1221, 0, 0, 1221, 1210, 1215, 00578 0, 734, 1655, 736, 1210, 1209, 739, 1655, 1655, 0, 00579 741, 0, 0, 1209, 0, 0, 743, 1200, 1194, 1180, 00580 0, 1172, 748, 1655, 1173, 0, 749, 0, 1176, 0, 00581 1162, 706, 1655, 1170, 1160, 756, 0, 754, 0, 1161, 00582 1164, 1160, 0, 1156, 759, 1655, 1158, 1147, 0, 1142, 00583 751, 755, 780, 1655, 0, 0, 1655, 1655, 768, 0, 00584 0, 1140, 1655, 761, 1655, 0, 1129, 1655, 772, 1655, 00585 1106, 777, 1120, 1116, 1121, 775, 1113, 784, 785, 1111, 00586 00587 0, 1104, 786, 1103, 788, 1100, 0, 1099, 1056, 1096, 00588 1058, 1055, 782, 789, 803, 790, 804, 1655, 1655, 805, 00589 808, 810, 812, 1090, 0, 1086, 1046, 1655, 1076, 940, 00590 0, 1655, 941, 940, 936, 935, 0, 0, 0, 0, 00591 1655, 923, 930, 926, 1655, 877, 851, 833, 0, 829, 00592 813, 779, 819, 1655, 326, 1655, 813, 1655, 817, 777, 00593 749, 742, 811, 830, 728, 836, 1655, 1655, 685, 719, 00594 701, 629, 839, 809, 841, 844, 845, 849, 853, 854, 00595 1655, 1655, 652, 1655, 1655, 1655, 1655, 0, 634, 1655, 00596 1655, 1655, 1655, 1655, 1655, 850, 1655, 1655, 1655, 1655, 00597 00598 855, 857, 872, 495, 481, 300, 859, 873, 874, 875, 00599 879, 881, 885, 0, 874, 890, 883, 243, 120, 893, 00600 899, 901, 906, 907, 909, 908, 100, 912, 913, 914, 00601 917, 919, 1655, 921, 922, 1655, 945, 956, 967, 978, 00602 989, 1000, 1011, 1022, 1033, 1044, 1055, 1066, 1077, 1082, 00603 1091, 1100, 1110, 1121, 1132, 1137, 1147, 1152, 1162, 1172, 00604 1182, 1193, 1198, 1203, 1213, 1220, 1230, 1241, 1246, 1250, 00605 1260, 1270, 1281, 1291, 1302, 1312, 1316, 1325, 1335, 1345, 00606 1355, 1366, 1377, 1388, 1399, 1409, 1419, 1430, 1441, 1444, 00607 1449, 1459, 1469, 1479, 1490, 1495, 1498, 1502, 1512, 1522, 00608 00609 1532, 1542, 1551, 1555, 1564, 1573, 1583, 1588, 1598, 1609, 00610 1615, 1624, 1633, 1635, 1644 00611 } ; 00612 00613 static yyconst flex_int16_t yy_def[516] = 00614 { 0, 00615 437, 437, 436, 436, 438, 438, 437, 437, 439, 439, 00616 440, 440, 436, 13, 436, 15, 441, 441, 442, 442, 00617 436, 21, 436, 23, 443, 443, 444, 444, 436, 29, 00618 445, 445, 436, 33, 446, 446, 447, 447, 448, 448, 00619 436, 41, 436, 43, 436, 45, 436, 436, 436, 436, 00620 436, 436, 436, 449, 436, 450, 450, 450, 450, 450, 00621 451, 449, 452, 452, 452, 452, 452, 436, 436, 436, 00622 436, 453, 436, 436, 436, 453, 454, 436, 436, 436, 00623 436, 436, 455, 436, 436, 455, 436, 436, 436, 436, 00624 456, 436, 436, 457, 436, 436, 436, 436, 458, 459, 00625 00626 436, 460, 436, 461, 436, 436, 462, 436, 436, 436, 00627 436, 436, 463, 436, 436, 436, 464, 436, 436, 436, 00628 436, 436, 436, 465, 436, 466, 436, 467, 436, 436, 00629 436, 436, 436, 436, 468, 436, 436, 436, 138, 436, 00630 469, 469, 469, 436, 469, 436, 436, 436, 436, 436, 00631 436, 436, 436, 470, 471, 436, 436, 472, 473, 436, 00632 436, 474, 475, 475, 436, 436, 475, 436, 436, 436, 00633 476, 476, 436, 436, 436, 436, 477, 436, 436, 436, 00634 478, 436, 449, 436, 436, 479, 436, 450, 450, 450, 00635 450, 450, 451, 449, 480, 480, 480, 480, 480, 481, 00636 00637 436, 452, 482, 452, 452, 452, 452, 436, 453, 436, 00638 483, 436, 436, 436, 453, 484, 454, 436, 436, 436, 00639 455, 436, 436, 455, 436, 436, 436, 436, 436, 456, 00640 436, 457, 485, 436, 458, 459, 460, 436, 486, 436, 00641 461, 436, 436, 436, 487, 488, 489, 463, 436, 490, 00642 491, 436, 436, 436, 436, 436, 492, 436, 467, 436, 00643 493, 436, 494, 436, 436, 436, 436, 436, 495, 436, 00644 436, 436, 436, 436, 496, 497, 436, 436, 497, 498, 00645 499, 436, 436, 436, 436, 500, 436, 436, 436, 436, 00646 501, 501, 436, 436, 436, 436, 502, 503, 503, 436, 00647 00648 504, 436, 436, 505, 506, 436, 507, 436, 508, 508, 00649 508, 508, 480, 480, 480, 480, 480, 436, 436, 452, 00650 452, 452, 452, 436, 483, 436, 436, 436, 436, 436, 00651 485, 436, 436, 486, 436, 436, 509, 510, 488, 461, 00652 436, 511, 436, 436, 436, 436, 493, 436, 494, 436, 00653 436, 436, 436, 436, 496, 436, 436, 436, 436, 436, 00654 436, 502, 512, 503, 505, 513, 436, 436, 508, 436, 00655 508, 508, 480, 480, 480, 480, 452, 436, 452, 452, 00656 436, 436, 436, 436, 436, 436, 436, 509, 511, 436, 00657 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 00658 00659 512, 503, 513, 508, 436, 508, 480, 436, 480, 480, 00660 452, 436, 452, 514, 436, 436, 503, 436, 508, 480, 00661 436, 480, 436, 452, 515, 503, 436, 436, 480, 436, 00662 436, 515, 436, 436, 436, 0, 436, 436, 436, 436, 00663 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 00664 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 00665 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 00666 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 00667 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 00668 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 00669 00670 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 00671 436, 436, 436, 436, 436 00672 } ; 00673 00674 static yyconst flex_int16_t yy_nxt[1702] = 00675 { 0, 00676 50, 51, 52, 50, 53, 54, 50, 55, 50, 50, 00677 50, 50, 50, 50, 50, 50, 50, 50, 50, 56, 00678 56, 56, 56, 56, 56, 56, 56, 50, 50, 50, 00679 56, 56, 57, 58, 56, 59, 60, 56, 56, 56, 00680 56, 56, 56, 56, 56, 50, 50, 61, 52, 50, 00681 53, 62, 50, 55, 50, 50, 50, 50, 50, 50, 00682 50, 50, 50, 50, 50, 63, 63, 63, 63, 63, 00683 63, 63, 63, 50, 50, 50, 63, 63, 64, 65, 00684 63, 66, 67, 63, 63, 63, 63, 63, 63, 63, 00685 63, 50, 69, 70, 84, 71, 72, 85, 73, 75, 00686 00687 70, 427, 71, 76, 182, 73, 78, 79, 183, 80, 00688 82, 79, 81, 80, 86, 84, 81, 201, 87, 101, 00689 102, 427, 103, 104, 208, 105, 106, 102, 209, 103, 00690 107, 101, 105, 74, 203, 214, 252, 253, 101, 215, 00691 74, 48, 88, 49, 48, 48, 48, 48, 48, 89, 00692 48, 48, 48, 48, 48, 48, 48, 48, 90, 48, 00693 91, 91, 91, 91, 91, 91, 91, 91, 48, 48, 00694 48, 91, 91, 91, 91, 91, 91, 91, 91, 91, 00695 91, 91, 91, 91, 91, 91, 48, 92, 93, 49, 00696 92, 92, 94, 92, 92, 48, 95, 92, 92, 96, 00697 00698 92, 92, 92, 92, 97, 98, 99, 99, 99, 99, 00699 99, 99, 99, 99, 92, 92, 92, 99, 99, 99, 00700 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 00701 99, 99, 92, 109, 222, 109, 256, 253, 223, 110, 00702 111, 110, 111, 112, 418, 112, 48, 48, 49, 48, 00703 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 00704 48, 48, 48, 48, 48, 113, 113, 113, 113, 113, 00705 113, 113, 113, 48, 48, 48, 113, 113, 113, 113, 00706 113, 113, 113, 113, 113, 113, 113, 113, 113, 113, 00707 113, 48, 48, 114, 49, 48, 48, 48, 48, 48, 00708 00709 115, 115, 48, 48, 115, 48, 48, 48, 48, 116, 00710 48, 117, 117, 117, 117, 117, 117, 117, 117, 48, 00711 48, 48, 117, 117, 117, 117, 117, 117, 117, 117, 00712 117, 117, 117, 117, 117, 117, 117, 48, 48, 118, 00713 119, 277, 121, 419, 278, 122, 48, 123, 119, 398, 00714 121, 125, 126, 122, 127, 128, 224, 129, 130, 126, 00715 225, 127, 128, 398, 129, 131, 132, 133, 131, 134, 00716 135, 131, 136, 137, 131, 131, 131, 131, 131, 138, 00717 139, 139, 131, 140, 141, 141, 141, 141, 141, 142, 00718 143, 141, 144, 131, 131, 141, 141, 141, 141, 141, 00719 00720 141, 141, 141, 141, 141, 141, 142, 141, 141, 145, 00721 146, 149, 149, 150, 149, 151, 149, 149, 149, 152, 00722 153, 149, 149, 149, 149, 149, 149, 149, 149, 149, 00723 154, 154, 154, 154, 154, 154, 154, 154, 152, 149, 00724 153, 154, 154, 154, 154, 154, 154, 154, 154, 154, 00725 154, 154, 154, 154, 154, 154, 152, 49, 49, 156, 00726 156, 201, 157, 157, 49, 49, 160, 160, 296, 161, 00727 161, 164, 164, 165, 165, 303, 166, 166, 203, 227, 00728 297, 231, 405, 158, 158, 232, 228, 304, 237, 258, 00729 162, 162, 238, 259, 205, 229, 418, 167, 167, 168, 00730 00731 169, 170, 168, 168, 168, 168, 168, 168, 168, 168, 00732 168, 168, 168, 168, 168, 168, 168, 168, 171, 171, 00733 171, 171, 171, 171, 171, 171, 168, 168, 168, 171, 00734 171, 171, 171, 171, 171, 172, 171, 171, 171, 171, 00735 171, 171, 171, 171, 168, 173, 174, 175, 173, 173, 00736 173, 173, 173, 173, 173, 176, 173, 173, 173, 173, 00737 173, 173, 173, 173, 177, 177, 177, 177, 177, 177, 00738 177, 177, 173, 173, 173, 177, 177, 177, 177, 177, 00739 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 00740 173, 178, 179, 180, 178, 178, 178, 178, 178, 178, 00741 00742 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 00743 181, 181, 181, 181, 181, 181, 181, 181, 178, 178, 00744 178, 181, 181, 181, 181, 181, 181, 181, 181, 181, 00745 181, 181, 181, 181, 181, 181, 178, 193, 201, 201, 00746 201, 194, 243, 244, 265, 266, 245, 250, 259, 273, 00747 273, 284, 285, 289, 290, 203, 203, 203, 436, 201, 00748 291, 436, 182, 291, 277, 414, 183, 278, 196, 197, 00749 406, 198, 199, 296, 204, 277, 203, 207, 278, 206, 00750 271, 272, 272, 273, 279, 297, 201, 193, 201, 274, 00751 274, 194, 201, 275, 201, 279, 201, 201, 201, 201, 00752 00753 201, 279, 405, 203, 274, 203, 201, 252, 253, 203, 00754 299, 203, 279, 203, 203, 203, 203, 203, 196, 197, 00755 370, 198, 199, 203, 314, 315, 316, 404, 320, 365, 00756 208, 317, 214, 321, 209, 222, 215, 224, 322, 223, 00757 227, 225, 231, 362, 237, 323, 232, 228, 238, 243, 00758 244, 341, 400, 245, 241, 258, 229, 256, 253, 259, 00759 265, 266, 357, 285, 259, 353, 353, 353, 271, 272, 00760 272, 273, 277, 359, 290, 278, 296, 274, 354, 436, 00761 399, 291, 395, 201, 291, 296, 296, 303, 297, 303, 00762 201, 201, 354, 271, 273, 273, 273, 297, 297, 304, 00763 00764 203, 304, 274, 274, 201, 201, 201, 203, 203, 378, 00765 408, 201, 296, 201, 357, 285, 394, 274, 359, 290, 00766 373, 203, 203, 203, 297, 364, 203, 203, 203, 375, 00767 203, 296, 393, 353, 353, 353, 392, 303, 374, 396, 00768 201, 397, 201, 297, 376, 201, 201, 377, 379, 304, 00769 378, 380, 346, 396, 412, 201, 296, 203, 296, 203, 00770 201, 415, 203, 203, 416, 416, 416, 203, 297, 402, 00771 297, 203, 203, 303, 408, 421, 201, 203, 346, 409, 00772 423, 407, 412, 410, 296, 304, 201, 411, 416, 416, 00773 416, 203, 203, 203, 428, 413, 297, 203, 417, 203, 00774 00775 421, 420, 201, 203, 416, 416, 416, 423, 430, 434, 00776 431, 203, 397, 428, 435, 430, 422, 203, 431, 203, 00777 431, 297, 434, 435, 203, 203, 426, 433, 424, 391, 00778 203, 203, 203, 390, 297, 433, 250, 433, 387, 386, 00779 203, 333, 333, 385, 429, 48, 48, 48, 48, 48, 00780 48, 48, 48, 48, 48, 48, 68, 68, 68, 68, 00781 68, 68, 68, 68, 68, 68, 68, 77, 77, 77, 00782 77, 77, 77, 77, 77, 77, 77, 77, 83, 83, 00783 83, 83, 83, 83, 83, 83, 83, 83, 83, 100, 00784 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 00785 00786 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 00787 108, 120, 120, 120, 120, 120, 120, 120, 120, 120, 00788 120, 120, 124, 124, 124, 124, 124, 124, 124, 124, 00789 124, 124, 124, 147, 147, 147, 147, 147, 147, 147, 00790 147, 147, 147, 147, 155, 155, 155, 155, 155, 155, 00791 155, 155, 155, 155, 155, 159, 159, 159, 159, 159, 00792 159, 159, 159, 159, 159, 159, 163, 163, 163, 163, 00793 163, 163, 163, 163, 163, 163, 163, 186, 186, 384, 00794 186, 383, 186, 186, 186, 186, 186, 186, 188, 382, 00795 188, 188, 195, 381, 372, 195, 371, 370, 369, 195, 00796 00797 195, 202, 368, 367, 365, 302, 202, 202, 202, 202, 00798 211, 211, 300, 211, 362, 211, 211, 211, 211, 211, 00799 211, 217, 295, 361, 360, 217, 217, 217, 217, 217, 00800 217, 217, 221, 221, 292, 221, 358, 221, 221, 221, 00801 221, 221, 221, 230, 356, 230, 230, 233, 233, 352, 00802 233, 351, 233, 233, 233, 233, 233, 233, 235, 267, 00803 235, 235, 236, 350, 348, 346, 345, 344, 236, 236, 00804 236, 236, 236, 239, 343, 250, 239, 249, 338, 336, 00805 239, 239, 241, 241, 335, 241, 241, 241, 241, 241, 00806 241, 241, 241, 246, 246, 333, 246, 246, 246, 246, 00807 00808 246, 246, 246, 246, 248, 332, 248, 248, 251, 251, 00809 234, 251, 251, 257, 226, 226, 220, 330, 257, 257, 00810 257, 257, 257, 257, 261, 329, 216, 327, 261, 261, 00811 263, 263, 326, 263, 324, 263, 263, 263, 263, 263, 00812 263, 269, 269, 200, 269, 269, 269, 269, 269, 269, 00813 269, 269, 276, 312, 276, 276, 280, 311, 280, 280, 00814 281, 281, 310, 309, 281, 281, 281, 281, 281, 281, 00815 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 00816 283, 286, 286, 308, 306, 286, 286, 286, 286, 286, 00817 286, 288, 288, 288, 288, 288, 288, 288, 288, 288, 00818 00819 288, 288, 291, 291, 291, 184, 291, 291, 291, 291, 00820 291, 291, 291, 298, 302, 300, 295, 298, 298, 294, 00821 298, 298, 301, 293, 301, 301, 305, 292, 292, 287, 00822 305, 305, 282, 305, 305, 307, 307, 270, 307, 307, 00823 307, 307, 307, 307, 307, 307, 313, 268, 267, 264, 00824 262, 313, 313, 313, 313, 318, 318, 318, 318, 260, 00825 318, 318, 318, 318, 318, 318, 319, 319, 319, 319, 00826 319, 319, 319, 255, 319, 319, 319, 325, 325, 254, 00827 325, 325, 325, 325, 325, 325, 325, 325, 328, 328, 00828 328, 328, 250, 328, 328, 328, 328, 328, 328, 331, 00829 00830 331, 249, 331, 331, 331, 331, 331, 331, 331, 331, 00831 334, 247, 242, 240, 234, 334, 226, 334, 334, 337, 00832 337, 220, 337, 337, 337, 337, 337, 337, 337, 337, 00833 339, 339, 219, 339, 339, 339, 339, 339, 339, 339, 00834 339, 340, 340, 340, 340, 340, 340, 340, 340, 340, 00835 340, 340, 342, 342, 251, 251, 218, 251, 251, 257, 00836 216, 213, 212, 210, 257, 257, 257, 257, 257, 257, 00837 347, 200, 192, 191, 190, 347, 189, 347, 347, 349, 00838 349, 187, 349, 349, 349, 349, 349, 349, 349, 349, 00839 269, 269, 185, 269, 269, 269, 269, 269, 269, 269, 00840 00841 269, 355, 184, 355, 276, 436, 276, 276, 280, 148, 00842 280, 280, 281, 281, 148, 49, 281, 281, 281, 281, 00843 281, 281, 286, 286, 49, 49, 286, 286, 286, 286, 00844 286, 286, 291, 291, 291, 49, 291, 291, 291, 291, 00845 291, 291, 291, 363, 436, 436, 436, 436, 436, 436, 00846 363, 363, 298, 436, 436, 436, 298, 298, 436, 298, 00847 298, 301, 436, 301, 301, 366, 436, 436, 436, 436, 00848 436, 436, 366, 366, 305, 436, 436, 436, 305, 305, 00849 436, 305, 305, 307, 307, 436, 307, 307, 307, 307, 00850 307, 307, 307, 307, 188, 436, 188, 188, 388, 388, 00851 00852 436, 388, 388, 388, 388, 388, 388, 388, 388, 341, 00853 341, 341, 341, 436, 341, 341, 341, 341, 341, 341, 00854 389, 389, 436, 389, 389, 401, 436, 436, 436, 401, 00855 401, 436, 401, 401, 403, 436, 436, 436, 403, 403, 00856 436, 403, 403, 425, 425, 432, 436, 436, 436, 436, 00857 432, 432, 432, 432, 47, 436, 436, 436, 436, 436, 00858 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 00859 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 00860 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 00861 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 00862 00863 436 00864 } ; 00865 00866 static yyconst flex_int16_t yy_chk[1702] = 00867 { 0, 00868 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 00869 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 00870 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 00871 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 00872 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 00873 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 00874 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 00875 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 00876 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 00877 4, 4, 5, 5, 11, 5, 5, 11, 5, 6, 00878 00879 6, 427, 6, 6, 51, 6, 9, 9, 51, 9, 00880 10, 10, 9, 10, 12, 12, 10, 63, 12, 17, 00881 17, 419, 17, 17, 69, 17, 18, 18, 69, 18, 00882 18, 17, 18, 5, 63, 75, 118, 118, 18, 75, 00883 6, 13, 13, 13, 13, 13, 13, 13, 13, 13, 00884 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 00885 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 00886 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 00887 13, 13, 13, 13, 13, 13, 13, 15, 15, 15, 00888 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 00889 00890 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 00891 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 00892 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 00893 15, 15, 15, 19, 84, 20, 123, 123, 84, 19, 00894 19, 20, 20, 19, 418, 20, 21, 21, 21, 21, 00895 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 00896 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 00897 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 00898 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 00899 21, 21, 23, 23, 23, 23, 23, 23, 23, 23, 00900 00901 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 00902 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 00903 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 00904 23, 23, 23, 23, 23, 23, 23, 23, 25, 25, 00905 25, 142, 25, 406, 142, 25, 26, 26, 26, 355, 00906 26, 27, 27, 26, 27, 27, 86, 27, 28, 28, 00907 86, 28, 28, 355, 28, 29, 29, 29, 29, 29, 00908 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 00909 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 00910 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 00911 00912 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 00913 29, 33, 33, 33, 33, 33, 33, 33, 33, 33, 00914 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 00915 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 00916 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 00917 33, 33, 33, 33, 33, 33, 33, 35, 36, 35, 00918 36, 65, 35, 36, 37, 38, 37, 38, 171, 37, 00919 38, 39, 40, 39, 40, 181, 39, 40, 65, 88, 00920 171, 93, 405, 35, 36, 93, 88, 181, 102, 125, 00921 37, 38, 102, 125, 65, 88, 404, 39, 40, 41, 00922 00923 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 00924 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 00925 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 00926 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 00927 41, 41, 41, 41, 41, 43, 43, 43, 43, 43, 00928 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 00929 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 00930 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 00931 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 00932 43, 45, 45, 45, 45, 45, 45, 45, 45, 45, 00933 00934 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 00935 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 00936 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 00937 45, 45, 45, 45, 45, 45, 45, 61, 64, 66, 00938 67, 61, 106, 106, 130, 130, 106, 389, 130, 139, 00939 139, 158, 158, 162, 162, 64, 66, 67, 167, 195, 00940 167, 139, 182, 167, 143, 383, 182, 143, 61, 61, 00941 372, 61, 61, 172, 64, 145, 195, 67, 145, 66, 00942 138, 138, 138, 138, 143, 172, 198, 193, 196, 138, 00943 138, 193, 197, 138, 199, 145, 201, 202, 204, 205, 00944 00945 206, 143, 371, 198, 138, 196, 207, 252, 252, 197, 00946 172, 199, 145, 201, 202, 204, 205, 206, 193, 193, 00947 370, 193, 193, 207, 196, 197, 198, 369, 204, 365, 00948 208, 199, 214, 205, 208, 222, 214, 224, 206, 222, 00949 227, 224, 231, 362, 237, 207, 231, 227, 237, 243, 00950 243, 247, 361, 243, 247, 258, 227, 256, 256, 258, 00951 265, 265, 284, 284, 265, 271, 271, 271, 272, 272, 00952 272, 272, 279, 289, 289, 279, 296, 272, 272, 292, 00953 360, 292, 352, 313, 292, 298, 299, 303, 296, 305, 00954 314, 316, 272, 273, 273, 273, 273, 298, 299, 303, 00955 00956 313, 305, 273, 273, 315, 317, 320, 314, 316, 321, 00957 374, 322, 363, 323, 357, 357, 351, 273, 359, 359, 00958 314, 315, 317, 320, 363, 299, 321, 374, 322, 316, 00959 323, 364, 350, 353, 353, 353, 348, 366, 315, 353, 00960 373, 353, 375, 364, 317, 376, 377, 320, 322, 366, 00961 378, 323, 347, 353, 379, 380, 401, 373, 402, 375, 00962 407, 396, 376, 377, 396, 396, 396, 378, 401, 364, 00963 402, 379, 380, 403, 408, 409, 410, 407, 346, 375, 00964 411, 373, 412, 376, 417, 403, 413, 377, 415, 415, 00965 415, 408, 409, 410, 420, 380, 417, 411, 402, 412, 00966 00967 421, 407, 422, 413, 416, 416, 416, 423, 424, 426, 00968 425, 420, 416, 428, 429, 430, 410, 421, 431, 422, 00969 432, 426, 434, 435, 423, 424, 417, 425, 413, 344, 00970 428, 429, 430, 343, 434, 431, 342, 432, 336, 335, 00971 435, 334, 333, 330, 422, 437, 437, 437, 437, 437, 00972 437, 437, 437, 437, 437, 437, 438, 438, 438, 438, 00973 438, 438, 438, 438, 438, 438, 438, 439, 439, 439, 00974 439, 439, 439, 439, 439, 439, 439, 439, 440, 440, 00975 440, 440, 440, 440, 440, 440, 440, 440, 440, 441, 00976 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, 00977 00978 442, 442, 442, 442, 442, 442, 442, 442, 442, 442, 00979 442, 443, 443, 443, 443, 443, 443, 443, 443, 443, 00980 443, 443, 444, 444, 444, 444, 444, 444, 444, 444, 00981 444, 444, 444, 445, 445, 445, 445, 445, 445, 445, 00982 445, 445, 445, 445, 446, 446, 446, 446, 446, 446, 00983 446, 446, 446, 446, 446, 447, 447, 447, 447, 447, 00984 447, 447, 447, 447, 447, 447, 448, 448, 448, 448, 00985 448, 448, 448, 448, 448, 448, 448, 449, 449, 329, 00986 449, 327, 449, 449, 449, 449, 449, 449, 450, 326, 00987 450, 450, 451, 324, 312, 451, 311, 310, 309, 451, 00988 00989 451, 452, 308, 306, 304, 302, 452, 452, 452, 452, 00990 453, 453, 300, 453, 297, 453, 453, 453, 453, 453, 00991 453, 454, 295, 294, 293, 454, 454, 454, 454, 454, 00992 454, 454, 455, 455, 291, 455, 287, 455, 455, 455, 00993 455, 455, 455, 456, 282, 456, 456, 457, 457, 270, 00994 457, 268, 457, 457, 457, 457, 457, 457, 458, 267, 00995 458, 458, 459, 264, 262, 261, 260, 255, 459, 459, 00996 459, 459, 459, 460, 254, 251, 460, 249, 245, 242, 00997 460, 460, 461, 461, 240, 461, 461, 461, 461, 461, 00998 461, 461, 461, 462, 462, 239, 462, 462, 462, 462, 00999 01000 462, 462, 462, 462, 463, 238, 463, 463, 464, 464, 01001 234, 464, 464, 465, 226, 225, 220, 219, 465, 465, 01002 465, 465, 465, 465, 466, 218, 215, 213, 466, 466, 01003 467, 467, 212, 467, 210, 467, 467, 467, 467, 467, 01004 467, 468, 468, 194, 468, 468, 468, 468, 468, 468, 01005 468, 468, 469, 192, 469, 469, 470, 191, 470, 470, 01006 471, 471, 190, 189, 471, 471, 471, 471, 471, 471, 01007 472, 472, 472, 472, 472, 472, 472, 472, 472, 472, 01008 472, 473, 473, 187, 185, 473, 473, 473, 473, 473, 01009 473, 474, 474, 474, 474, 474, 474, 474, 474, 474, 01010 01011 474, 474, 475, 475, 475, 184, 475, 475, 475, 475, 01012 475, 475, 475, 476, 179, 174, 169, 476, 476, 166, 01013 476, 476, 477, 165, 477, 477, 478, 164, 163, 161, 01014 478, 478, 156, 478, 478, 479, 479, 136, 479, 479, 01015 479, 479, 479, 479, 479, 479, 480, 134, 132, 129, 01016 127, 480, 480, 480, 480, 481, 481, 481, 481, 126, 01017 481, 481, 481, 481, 481, 481, 482, 482, 482, 482, 01018 482, 482, 482, 122, 482, 482, 482, 483, 483, 121, 01019 483, 483, 483, 483, 483, 483, 483, 483, 484, 484, 01020 484, 484, 117, 484, 484, 484, 484, 484, 484, 485, 01021 01022 485, 114, 485, 485, 485, 485, 485, 485, 485, 485, 01023 486, 107, 105, 103, 97, 486, 87, 486, 486, 487, 01024 487, 82, 487, 487, 487, 487, 487, 487, 487, 487, 01025 488, 488, 81, 488, 488, 488, 488, 488, 488, 488, 01026 488, 489, 489, 489, 489, 489, 489, 489, 489, 489, 01027 489, 489, 490, 490, 491, 491, 80, 491, 491, 492, 01028 76, 74, 73, 71, 492, 492, 492, 492, 492, 492, 01029 493, 62, 60, 59, 58, 493, 57, 493, 493, 494, 01030 494, 55, 494, 494, 494, 494, 494, 494, 494, 494, 01031 495, 495, 53, 495, 495, 495, 495, 495, 495, 495, 01032 01033 495, 496, 52, 496, 497, 47, 497, 497, 498, 32, 01034 498, 498, 499, 499, 31, 8, 499, 499, 499, 499, 01035 499, 499, 500, 500, 7, 2, 500, 500, 500, 500, 01036 500, 500, 501, 501, 501, 1, 501, 501, 501, 501, 01037 501, 501, 501, 502, 0, 0, 0, 0, 0, 0, 01038 502, 502, 503, 0, 0, 0, 503, 503, 0, 503, 01039 503, 504, 0, 504, 504, 505, 0, 0, 0, 0, 01040 0, 0, 505, 505, 506, 0, 0, 0, 506, 506, 01041 0, 506, 506, 507, 507, 0, 507, 507, 507, 507, 01042 507, 507, 507, 507, 508, 0, 508, 508, 509, 509, 01043 01044 0, 509, 509, 509, 509, 509, 509, 509, 509, 510, 01045 510, 510, 510, 0, 510, 510, 510, 510, 510, 510, 01046 511, 511, 0, 511, 511, 512, 0, 0, 0, 512, 01047 512, 0, 512, 512, 513, 0, 0, 0, 513, 513, 01048 0, 513, 513, 514, 514, 515, 0, 0, 0, 0, 01049 515, 515, 515, 515, 436, 436, 436, 436, 436, 436, 01050 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 01051 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 01052 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 01053 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, 01054 01055 436 01056 } ; 01057 01058 extern int pyscanYY_flex_debug; 01059 int pyscanYY_flex_debug = 0; 01060 01061 static yy_state_type *yy_state_buf=0, *yy_state_ptr=0; 01062 static char *yy_full_match; 01063 static int yy_lp; 01064 static int yy_looking_for_trail_begin = 0; 01065 static int yy_full_lp; 01066 static int *yy_full_state; 01067 #define YY_TRAILING_MASK 0x2000 01068 #define YY_TRAILING_HEAD_MASK 0x4000 01069 #define REJECT \ 01070 { \ 01071 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscanYYtext */ \ 01072 yy_cp = (yy_full_match); /* restore poss. backed-over text */ \ 01073 (yy_lp) = yy_full_lp; /* restore orig. accepting pos. */ \ 01074 (yy_state_ptr) = yy_full_state; /* restore orig. state */ \ 01075 yy_current_state = *(yy_state_ptr); /* restore curr. state */ \ 01076 ++(yy_lp); \ 01077 goto find_rule; \ 01078 } 01079 01080 #define yymore() yymore_used_but_not_detected 01081 #define YY_MORE_ADJ 0 01082 #define YY_RESTORE_YY_MORE_OFFSET 01083 char *pyscanYYtext; 01084 #line 1 "pyscanner.l" 01085 /****************************************************************************** 01086 * 01087 * $Id: pyscanner.l,v 1.9 2001/03/19 19:27:39 root Exp $ 01088 * 01089 * Copyright (C) 1997-2008 by Dimitri van Heesch. 01090 * 01091 * Permission to use, copy, modify, and distribute this software and its 01092 * documentation under the terms of the GNU General Public License is hereby 01093 * granted. No representations are made about the suitability of this software 01094 * for any purpose. It is provided "as is" without express or implied warranty. 01095 * See the GNU General Public License for more details. 01096 * 01097 * Documents produced by Doxygen are derivative works derived from the 01098 * input used in their production; they are not affected by this license. 01099 * 01100 */ 01101 /* This code is based on the work done by the MoxyPyDoxy team 01102 * (Linda Leong, Mike Rivera, Kim Truong, and Gabriel Estrada) 01103 * in Spring 2005 as part of CS 179E: Compiler Design Project 01104 * at the University of California, Riverside; the course was 01105 * taught by Peter H. Froehlich <phf@acm.org>. 01106 */ 01107 #line 26 "pyscanner.l" 01108 01109 /* 01110 * includes 01111 */ 01112 #include <stdio.h> 01113 #include <stdlib.h> 01114 #include <assert.h> 01115 #include <ctype.h> 01116 01117 #include "qtbc.h" 01118 #include <qarray.h> 01119 #include <qstack.h> 01120 #include <qregexp.h> 01121 #include <unistd.h> 01122 #include <qfile.h> 01123 #include <qfileinfo.h> 01124 01125 #include "pyscanner.h" 01126 #include "entry.h" 01127 #include "message.h" 01128 #include "config.h" 01129 #include "doxygen.h" 01130 #include "util.h" 01131 #include "defargs.h" 01132 #include "language.h" 01133 #include "commentscan.h" 01134 #include "pycode.h" 01135 01136 #define YY_NEVER_INTERACTIVE 1 01137 01138 /* ----------------------------------------------------------------- 01139 * 01140 * statics 01141 */ 01142 01143 01144 static ParserInterface *g_thisParser; 01145 static const char * inputString; 01146 static int inputPosition; 01147 static QFile inputFile; 01148 01149 static Protection protection; 01150 01151 static Entry* current_root = 0 ; 01152 static Entry* current = 0 ; 01153 static Entry* previous = 0 ; 01154 static Entry* bodyEntry = 0 ; 01155 static int yyLineNr = 1 ; 01156 static QCString yyFileName; 01157 static MethodTypes mtype; 01158 static bool gstat; 01159 static Specifier virt; 01160 01161 static int docBlockContext; 01162 static QCString docBlock; 01163 static QCString docBlockName; 01164 static bool docBlockInBody; 01165 static bool docBlockJavaStyle; 01166 static bool docBrief; 01167 static bool docBlockSpecial; 01168 01169 static bool g_doubleQuote; 01170 static bool g_specialBlock; 01171 static int g_stringContext; 01172 static QGString * g_copyString; 01173 static int g_indent = 0; 01174 static int g_curIndent = 0; 01175 01176 static QDict<QCString> g_packageNameCache(257); 01177 static QCString g_packageScope; 01178 01179 static char g_atomStart; 01180 static char g_atomEnd; 01181 static int g_atomCount; 01182 01183 //static bool g_insideConstructor; 01184 01185 static QCString g_moduleScope; 01186 static QCString g_packageName; 01187 01188 static bool g_hideClassDocs; 01189 01190 static QCString g_defVal; 01191 static int g_braceCount; 01192 01193 static bool g_lexInit = FALSE; 01194 static bool g_packageCommentAllowed; 01195 01196 //----------------------------------------------------------------------------- 01197 01198 01199 static void initParser() 01200 { 01201 protection = Public; 01202 mtype = Method; 01203 gstat = FALSE; 01204 virt = Normal; 01205 previous = 0; 01206 g_packageCommentAllowed = TRUE; 01207 g_packageNameCache.setAutoDelete(TRUE); 01208 } 01209 01210 static void initEntry() 01211 { 01212 //current->python = TRUE; 01213 current->protection = protection ; 01214 current->mtype = mtype; 01215 current->virt = virt; 01216 current->stat = gstat; 01217 current->objc = FALSE; //insideObjC; 01218 current->setParent(current_root); 01219 initGroupInfo(current); 01220 } 01221 01222 static void newEntry() 01223 { 01224 previous = current; 01225 current_root->addSubEntry(current); 01226 current = new Entry ; 01227 initEntry(); 01228 } 01229 01230 static void newVariable() 01231 { 01232 if (!current->name.isEmpty() && current->name.at(0)=='_') // mark as private 01233 { 01234 current->protection=Private; 01235 } 01236 if (current_root->section&Entry::COMPOUND_MASK) // mark as class variable 01237 { 01238 current->stat = TRUE; 01239 } 01240 newEntry(); 01241 } 01242 01243 static void newFunction() 01244 { 01245 if (current->name.left(2)=="__" && current->name.right(2)=="__") 01246 { 01247 // special method name, see 01248 // http://docs.python.org/ref/specialnames.html 01249 current->protection=Public; 01250 } 01251 else if (current->name.at(0)=='_') 01252 { 01253 current->protection=Private; 01254 } 01255 } 01256 01257 static inline int computeIndent(const char *s) 01258 { 01259 int col=0; 01260 static int tabSize=Config_getInt("TAB_SIZE"); 01261 const char *p=s; 01262 char c; 01263 while ((c=*p++)) 01264 { 01265 if (c==' ') col++; 01266 else if (c=='\t') col+=tabSize-(col%tabSize); 01267 else break; 01268 } 01269 return col; 01270 } 01271 01272 static QCString findPackageScopeFromPath(const QCString &path) 01273 { 01274 QCString *pScope = g_packageNameCache.find(path); 01275 if (pScope) 01276 { 01277 return *pScope; 01278 } 01279 QFileInfo pf(path+"/__init__.py"); // found package initialization file 01280 if (pf.exists()) 01281 { 01282 int i=path.findRev('/'); 01283 if (i!=-1) 01284 { 01285 QCString scope = findPackageScopeFromPath(path.left(i)); 01286 if (!scope.isEmpty()) 01287 { 01288 scope+="::"; 01289 } 01290 scope+=path.mid(i+1); 01291 g_packageNameCache.insert(path,new QCString(scope)); 01292 return scope; 01293 } 01294 } 01295 return ""; 01296 } 01297 01298 static QCString findPackageScope(const char *fileName) 01299 { 01300 if (fileName==0) return ""; 01301 QFileInfo fi(fileName); 01302 return findPackageScopeFromPath(fi.dirPath(TRUE).data()); 01303 } 01304 01305 //----------------------------------------------------------------------------- 01306 01307 static void lineCount() 01308 { 01309 for( const char* c = pyscanYYtext ; *c ; ++c ) 01310 yyLineNr += (*c == '\n') ; 01311 } 01312 01313 #if 0 01314 // Appends the current-name to current-type; 01315 // Destroys current-name. 01316 // Destroys current->args and current->argList 01317 static void addType( Entry* current ) 01318 { 01319 uint tl=current->type.length(); 01320 if ( tl>0 && !current->name.isEmpty() && current->type.at(tl-1)!='.') 01321 { 01322 current->type += ' ' ; 01323 } 01324 current->type += current->name ; 01325 current->name.resize(0) ; 01326 tl=current->type.length(); 01327 if ( tl>0 && !current->args.isEmpty() && current->type.at(tl-1)!='.') 01328 { 01329 current->type += ' ' ; 01330 } 01331 current->type += current->args ; 01332 current->args.resize(0) ; 01333 current->argList->clear(); 01334 } 01335 01336 static QCString stripQuotes(const char *s) 01337 { 01338 QCString name; 01339 if (s==0 || *s==0) return name; 01340 name=s; 01341 if (name.at(0)=='"' && name.at(name.length()-1)=='"') 01342 { 01343 name=name.mid(1,name.length()-2); 01344 } 01345 return name; 01346 } 01347 #endif 01348 //----------------------------------------------------------------- 01349 01350 //----------------------------------------------------------------- 01351 static void startCommentBlock(bool brief) 01352 { 01353 if (brief) 01354 { 01355 current->briefFile = yyFileName; 01356 current->briefLine = yyLineNr; 01357 } 01358 else 01359 { 01360 current->docFile = yyFileName; 01361 current->docLine = yyLineNr; 01362 } 01363 } 01364 01365 /* 01366 static void appendDocBlock() { 01367 previous = current; 01368 current_root->addSubEntry(current); 01369 current = new Entry; 01370 initEntry(); 01371 } 01372 */ 01373 01374 static void handleCommentBlock(const QCString &doc,bool brief) 01375 { 01376 //printf("handleCommentBlock(doc=[%s] brief=%d docBlockInBody=%d docBlockJavaStyle=%d\n", 01377 // doc.data(),brief,docBlockInBody,docBlockJavaStyle); 01378 01379 // TODO: Fix me 01380 docBlockInBody=FALSE; 01381 01382 if (docBlockInBody && previous && !previous->doc.isEmpty()) 01383 { 01384 previous->doc=previous->doc.stripWhiteSpace()+"\n\n"; 01385 } 01386 01387 int position = 0; 01388 bool needsEntry; 01389 while (parseCommentBlock( 01390 g_thisParser, 01391 (docBlockInBody && previous) ? previous : current, 01392 doc, // text 01393 yyFileName, // file 01394 brief ? current->briefLine : current->docLine, // line of block start 01395 docBlockInBody ? FALSE : brief, 01396 docBlockJavaStyle, // javadoc style // or FALSE, 01397 docBlockInBody, 01398 protection, 01399 position, 01400 needsEntry) 01401 ) // need to start a new entry 01402 { 01403 if (needsEntry) 01404 { 01405 newEntry(); 01406 } 01407 } 01408 if (needsEntry) 01409 { 01410 newEntry(); 01411 } 01412 01413 } 01414 01415 static void endOfDef() 01416 { 01417 if (bodyEntry) 01418 { 01419 bodyEntry->endBodyLine = yyLineNr; 01420 bodyEntry = 0; 01421 } 01422 newEntry(); 01423 //g_insideConstructor = FALSE; 01424 } 01425 01426 static inline void addToString(const char *s) 01427 { 01428 if (g_copyString) (*g_copyString)+=s; 01429 } 01430 01431 static void initTriDoubleQuoteBlock() 01432 { 01433 docBlockContext = YY_START; 01434 docBlockInBody = FALSE; 01435 docBlockJavaStyle = TRUE; 01436 docBlockSpecial = pyscanYYtext[3]=='!'; 01437 docBlock.resize(0); 01438 g_doubleQuote = TRUE; 01439 startCommentBlock(FALSE); 01440 } 01441 01442 static void initTriSingleQuoteBlock() 01443 { 01444 docBlockContext = YY_START; 01445 docBlockInBody = FALSE; 01446 docBlockJavaStyle = TRUE; 01447 docBlockSpecial = pyscanYYtext[3]=='!'; 01448 docBlock.resize(0); 01449 g_doubleQuote = FALSE; 01450 startCommentBlock(FALSE); 01451 } 01452 01453 static void initSpecialBlock() 01454 { 01455 docBlockContext = YY_START; 01456 docBlockInBody = FALSE; 01457 docBlockJavaStyle = TRUE; 01458 docBrief = TRUE; 01459 docBlock.resize(0); 01460 startCommentBlock(TRUE); 01461 } 01462 01463 //----------------------------------------------------------------------------- 01464 /* ----------------------------------------------------------------- */ 01465 #undef YY_INPUT 01466 #define YY_INPUT(buf,result,max_size) result=yyread(buf,max_size); 01467 01468 static int yyread(char *buf,int max_size) 01469 { 01470 int c=0; 01471 while ( c < max_size && inputString[inputPosition] ) 01472 { 01473 *buf = inputString[inputPosition++] ; 01474 //printf("%d (%c)\n",*buf,*buf); 01475 c++; buf++; 01476 } 01477 return c; 01478 } 01479 01480 /* start command character */ 01481 /* Main start state */ 01482 01483 01484 /* Mid-comment states */ 01485 /* %x FuncDoubleComment */ 01486 /* %x ClassDoubleComment */ 01487 01488 01489 01490 /* Function states */ 01491 01492 01493 01494 01495 /* Class states */ 01496 01497 01498 01499 01500 /* Variable states */ 01501 01502 01503 01504 /* String states */ 01505 01506 01507 01508 /* import */ 01509 01510 01511 01512 #line 1513 "<stdout>" 01513 01514 #define INITIAL 0 01515 #define Search 1 01516 #define SearchMemVars 2 01517 #define TryClassDocString 3 01518 #define TripleComment 4 01519 #define SpecialComment 5 01520 #define FunctionDec 6 01521 #define FunctionParams 7 01522 #define FunctionBody 8 01523 #define FunctionParamDefVal 9 01524 #define ClassDec 10 01525 #define ClassInheritance 11 01526 #define ClassCaptureIndent 12 01527 #define ClassBody 13 01528 #define VariableDec 14 01529 #define VariableEnd 15 01530 #define VariableAtom 16 01531 #define SingleQuoteString 17 01532 #define DoubleQuoteString 18 01533 #define TripleString 19 01534 #define FromMod 20 01535 #define FromModItem 21 01536 #define Import 22 01537 01538 #ifndef YY_NO_UNISTD_H 01539 /* Special case for "unistd.h", since it is non-ANSI. We include it way 01540 * down here because we want the user's section 1 to have been scanned first. 01541 * The user has a chance to override it with an option. 01542 */ 01543 #include <unistd.h> 01544 #endif 01545 01546 #ifndef YY_EXTRA_TYPE 01547 #define YY_EXTRA_TYPE void * 01548 #endif 01549 01550 static int yy_init_globals (void ); 01551 01552 /* Macros after this point can all be overridden by user definitions in 01553 * section 1. 01554 */ 01555 01556 #ifndef YY_SKIP_YYWRAP 01557 #ifdef __cplusplus 01558 extern "C" int pyscanYYwrap (void ); 01559 #else 01560 extern int pyscanYYwrap (void ); 01561 #endif 01562 #endif 01563 01564 static void yyunput (int c,char *buf_ptr ); 01565 01566 #ifndef yytext_ptr 01567 static void yy_flex_strncpy (char *,yyconst char *,int ); 01568 #endif 01569 01570 #ifdef YY_NEED_STRLEN 01571 static int yy_flex_strlen (yyconst char * ); 01572 #endif 01573 01574 #ifndef YY_NO_INPUT 01575 01576 #ifdef __cplusplus 01577 static int yyinput (void ); 01578 #else 01579 static int input (void ); 01580 #endif 01581 01582 #endif 01583 01584 /* Amount of stuff to slurp up with each read. */ 01585 #ifndef YY_READ_BUF_SIZE 01586 #define YY_READ_BUF_SIZE 8192 01587 #endif 01588 01589 /* Copy whatever the last rule matched to the standard output. */ 01590 #ifndef ECHO 01591 /* This used to be an fputs(), but since the string might contain NUL's, 01592 * we now use fwrite(). 01593 */ 01594 #define ECHO (void) fwrite( pyscanYYtext, pyscanYYleng, 1, pyscanYYout ) 01595 #endif 01596 01597 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 01598 * is returned in "result". 01599 */ 01600 #ifndef YY_INPUT 01601 #define YY_INPUT(buf,result,max_size) \ 01602 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 01603 { \ 01604 int c = '*'; \ 01605 size_t n; \ 01606 for ( n = 0; n < max_size && \ 01607 (c = getc( pyscanYYin )) != EOF && c != '\n'; ++n ) \ 01608 buf[n] = (char) c; \ 01609 if ( c == '\n' ) \ 01610 buf[n++] = (char) c; \ 01611 if ( c == EOF && ferror( pyscanYYin ) ) \ 01612 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 01613 result = n; \ 01614 } \ 01615 else \ 01616 { \ 01617 errno=0; \ 01618 while ( (result = fread(buf, 1, max_size, pyscanYYin))==0 && ferror(pyscanYYin)) \ 01619 { \ 01620 if( errno != EINTR) \ 01621 { \ 01622 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 01623 break; \ 01624 } \ 01625 errno=0; \ 01626 clearerr(pyscanYYin); \ 01627 } \ 01628 }\ 01629 \ 01630 01631 #endif 01632 01633 /* No semi-colon after return; correct usage is to write "yyterminate();" - 01634 * we don't want an extra ';' after the "return" because that will cause 01635 * some compilers to complain about unreachable statements. 01636 */ 01637 #ifndef yyterminate 01638 #define yyterminate() return YY_NULL 01639 #endif 01640 01641 /* Number of entries by which start-condition stack grows. */ 01642 #ifndef YY_START_STACK_INCR 01643 #define YY_START_STACK_INCR 25 01644 #endif 01645 01646 /* Report a fatal error. */ 01647 #ifndef YY_FATAL_ERROR 01648 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 01649 #endif 01650 01651 /* end tables serialization structures and prototypes */ 01652 01653 /* Default declaration of generated scanner - a define so the user can 01654 * easily add parameters. 01655 */ 01656 #ifndef YY_DECL 01657 #define YY_DECL_IS_OURS 1 01658 01659 extern int pyscanYYlex (void); 01660 01661 #define YY_DECL int pyscanYYlex (void) 01662 #endif /* !YY_DECL */ 01663 01664 /* Code executed at the beginning of each rule, after pyscanYYtext and pyscanYYleng 01665 * have been set up. 01666 */ 01667 #ifndef YY_USER_ACTION 01668 #define YY_USER_ACTION 01669 #endif 01670 01671 /* Code executed at the end of each rule. */ 01672 #ifndef YY_BREAK 01673 #define YY_BREAK break; 01674 #endif 01675 01676 #define YY_RULE_SETUP \ 01677 if ( pyscanYYleng > 0 ) \ 01678 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ 01679 (pyscanYYtext[pyscanYYleng - 1] == '\n'); \ 01680 YY_USER_ACTION 01681 01684 YY_DECL 01685 { 01686 register yy_state_type yy_current_state; 01687 register char *yy_cp, *yy_bp; 01688 register int yy_act; 01689 01690 #line 489 "pyscanner.l" 01691 01692 01693 /* ------------ Function recognition rules -------------- */ 01694 01695 #line 1696 "<stdout>" 01696 01697 if ( !(yy_init) ) 01698 { 01699 (yy_init) = 1; 01700 01701 #ifdef YY_USER_INIT 01702 YY_USER_INIT; 01703 #endif 01704 01705 /* Create the reject buffer large enough to save one state per allowed character. */ 01706 if ( ! (yy_state_buf) ) 01707 (yy_state_buf) = (yy_state_type *)pyscanYYalloc(YY_STATE_BUF_SIZE ); 01708 01709 if ( ! (yy_start) ) 01710 (yy_start) = 1; /* first start state */ 01711 01712 if ( ! pyscanYYin ) 01713 pyscanYYin = stdin; 01714 01715 if ( ! pyscanYYout ) 01716 pyscanYYout = stdout; 01717 01718 if ( ! YY_CURRENT_BUFFER ) { 01719 pyscanYYensure_buffer_stack (); 01720 YY_CURRENT_BUFFER_LVALUE = 01721 pyscanYY_create_buffer(pyscanYYin,YY_BUF_SIZE ); 01722 } 01723 01724 pyscanYY_load_buffer_state( ); 01725 } 01726 01727 while ( 1 ) /* loops until end-of-file is reached */ 01728 { 01729 yy_cp = (yy_c_buf_p); 01730 01731 /* Support of pyscanYYtext. */ 01732 *yy_cp = (yy_hold_char); 01733 01734 /* yy_bp points to the position in yy_ch_buf of the start of 01735 * the current run. 01736 */ 01737 yy_bp = yy_cp; 01738 01739 yy_current_state = (yy_start); 01740 yy_current_state += YY_AT_BOL(); 01741 01742 (yy_state_ptr) = (yy_state_buf); 01743 *(yy_state_ptr)++ = yy_current_state; 01744 01745 yy_match: 01746 do 01747 { 01748 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 01749 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 01750 { 01751 yy_current_state = (int) yy_def[yy_current_state]; 01752 if ( yy_current_state >= 437 ) 01753 yy_c = yy_meta[(unsigned int) yy_c]; 01754 } 01755 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 01756 *(yy_state_ptr)++ = yy_current_state; 01757 ++yy_cp; 01758 } 01759 while ( yy_base[yy_current_state] != 1655 ); 01760 01761 yy_find_action: 01762 yy_current_state = *--(yy_state_ptr); 01763 (yy_lp) = yy_accept[yy_current_state]; 01764 find_rule: /* we branch to this label when backing up */ 01765 for ( ; ; ) /* until we find what rule we matched */ 01766 { 01767 if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] ) 01768 { 01769 yy_act = yy_acclist[(yy_lp)]; 01770 if ( yy_act & YY_TRAILING_HEAD_MASK || 01771 yy_looking_for_trail_begin ) 01772 { 01773 if ( yy_act == yy_looking_for_trail_begin ) 01774 { 01775 yy_looking_for_trail_begin = 0; 01776 yy_act &= ~YY_TRAILING_HEAD_MASK; 01777 break; 01778 } 01779 } 01780 else if ( yy_act & YY_TRAILING_MASK ) 01781 { 01782 yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK; 01783 yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK; 01784 } 01785 else 01786 { 01787 (yy_full_match) = yy_cp; 01788 yy_full_state = (yy_state_ptr); 01789 yy_full_lp = (yy_lp); 01790 break; 01791 } 01792 ++(yy_lp); 01793 goto find_rule; 01794 } 01795 --yy_cp; 01796 yy_current_state = *--(yy_state_ptr); 01797 (yy_lp) = yy_accept[yy_current_state]; 01798 } 01799 01800 YY_DO_BEFORE_ACTION; 01801 01802 do_action: /* This label is used only to access EOF actions. */ 01803 01804 switch ( yy_act ) 01805 { /* beginning of action switch */ 01806 01807 case 1: 01808 #line 496 "pyscanner.l" 01809 case 2: 01810 YY_RULE_SETUP 01811 #line 496 "pyscanner.l" 01812 { // start of a function/method definition 01813 g_indent=computeIndent(pyscanYYtext); 01814 current->fileName = yyFileName; 01815 current->startLine = yyLineNr; 01816 current->bodyLine = yyLineNr; 01817 current->section = Entry::FUNCTION_SEC; 01818 current->protection = protection = Public; 01819 current->objc = FALSE; 01820 current->virt = Normal; 01821 current->stat = FALSE; 01822 current->mtype = mtype = Method; 01823 current->type.resize(0); 01824 current->name.resize(0); 01825 current->args.resize(0); 01826 current->argList->clear(); 01827 g_packageCommentAllowed = FALSE; 01828 BEGIN( FunctionDec ); 01829 } 01830 YY_BREAK 01831 case 3: 01832 #line 516 "pyscanner.l" 01833 case 4: 01834 YY_RULE_SETUP 01835 #line 516 "pyscanner.l" 01836 { // start of a class definition 01837 g_indent=computeIndent(pyscanYYtext); 01838 current->section = Entry::CLASS_SEC; 01839 current->argList->clear(); 01840 current->type += "class" ; 01841 current->fileName = yyFileName; 01842 current->bodyLine = yyLineNr; 01843 g_packageCommentAllowed = FALSE; 01844 01845 BEGIN( ClassDec ) ; 01846 } 01847 YY_BREAK 01848 case 5: 01849 #line 528 "pyscanner.l" 01850 case 6: 01851 YY_RULE_SETUP 01852 #line 528 "pyscanner.l" 01853 { // start of an from import 01854 g_packageCommentAllowed = FALSE; 01855 BEGIN( FromMod ); 01856 } 01857 YY_BREAK 01858 case 7: 01859 #line 534 "pyscanner.l" 01860 case 8: 01861 YY_RULE_SETUP 01862 #line 534 "pyscanner.l" 01863 { // start of an import statement 01864 g_packageCommentAllowed = FALSE; 01865 BEGIN( Import ); 01866 } 01867 YY_BREAK 01868 case 9: 01869 /* rule 9 can match eol */ 01870 YY_RULE_SETUP 01871 #line 538 "pyscanner.l" 01872 { // variable 01873 g_indent=computeIndent(pyscanYYtext); 01874 current->section = Entry::VARIABLE_SEC; 01875 current->name = QCString(pyscanYYtext).stripWhiteSpace(); 01876 current->fileName = yyFileName; 01877 current->startLine = yyLineNr; 01878 current->bodyLine = yyLineNr; 01879 g_packageCommentAllowed = FALSE; 01880 BEGIN(VariableDec); 01881 } 01882 YY_BREAK 01883 case 10: 01884 YY_RULE_SETUP 01885 #line 548 "pyscanner.l" 01886 { // start of a single quoted string 01887 g_stringContext=YY_START; 01888 g_copyString=0; 01889 g_packageCommentAllowed = FALSE; 01890 BEGIN( SingleQuoteString ); 01891 } 01892 YY_BREAK 01893 case 11: 01894 YY_RULE_SETUP 01895 #line 554 "pyscanner.l" 01896 { // start of a double quoted string 01897 g_stringContext=YY_START; 01898 g_copyString=0; 01899 g_packageCommentAllowed = FALSE; 01900 BEGIN( DoubleQuoteString ); 01901 } 01902 YY_BREAK 01903 case 12: 01904 YY_RULE_SETUP 01905 #line 561 "pyscanner.l" 01906 { // normal comment 01907 g_packageCommentAllowed = FALSE; 01908 } 01909 YY_BREAK 01910 case 13: 01911 YY_RULE_SETUP 01912 #line 564 "pyscanner.l" 01913 { // some other identifier 01914 g_packageCommentAllowed = FALSE; 01915 } 01916 YY_BREAK 01917 case 14: 01918 YY_RULE_SETUP 01919 #line 567 "pyscanner.l" 01920 { 01921 g_curIndent=computeIndent(pyscanYYtext); 01922 } 01923 YY_BREAK 01924 case 15: 01925 YY_RULE_SETUP 01926 #line 570 "pyscanner.l" 01927 { // any other character... 01928 // This is the major default 01929 // that should catch everything 01930 // else in Body. 01931 } 01932 YY_BREAK 01933 case 16: 01934 /* rule 16 can match eol */ 01935 YY_RULE_SETUP 01936 #line 576 "pyscanner.l" 01937 { // new line 01938 lineCount(); 01939 } 01940 YY_BREAK 01941 case 17: 01942 YY_RULE_SETUP 01943 #line 580 "pyscanner.l" 01944 { // start of a comment block 01945 initTriDoubleQuoteBlock(); 01946 BEGIN(TripleComment); 01947 } 01948 YY_BREAK 01949 case 18: 01950 YY_RULE_SETUP 01951 #line 585 "pyscanner.l" 01952 { // start of a comment block 01953 initTriSingleQuoteBlock(); 01954 BEGIN(TripleComment); 01955 } 01956 YY_BREAK 01957 case 19: 01958 /* rule 19 can match eol */ 01959 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscanYYtext */ 01960 (yy_c_buf_p) = yy_cp -= 1; 01961 YY_DO_BEFORE_ACTION; /* set up pyscanYYtext again */ 01962 YY_RULE_SETUP 01963 #line 590 "pyscanner.l" 01964 { // start of a special comment 01965 g_packageCommentAllowed = FALSE; 01966 initSpecialBlock(); 01967 BEGIN(SpecialComment); 01968 } 01969 YY_BREAK 01970 01971 01972 case 20: 01973 YY_RULE_SETUP 01974 #line 598 "pyscanner.l" 01975 { // from package import 01976 g_packageName=pyscanYYtext; 01977 } 01978 YY_BREAK 01979 case 21: 01980 YY_RULE_SETUP 01981 #line 601 "pyscanner.l" 01982 { 01983 BEGIN(FromModItem); 01984 } 01985 YY_BREAK 01986 case 22: 01987 /* rule 22 can match eol */ 01988 YY_RULE_SETUP 01989 #line 604 "pyscanner.l" 01990 { 01991 yyLineNr++; 01992 BEGIN(Search); 01993 } 01994 YY_BREAK 01995 case 23: 01996 YY_RULE_SETUP 01997 #line 608 "pyscanner.l" 01998 { 01999 } 02000 YY_BREAK 02001 case 24: 02002 YY_RULE_SETUP 02003 #line 610 "pyscanner.l" 02004 { 02005 unput(*pyscanYYtext); 02006 BEGIN(Search); 02007 } 02008 YY_BREAK 02009 02010 02011 case 25: 02012 YY_RULE_SETUP 02013 #line 617 "pyscanner.l" 02014 { // import all 02015 QCString item=g_packageName; 02016 current->name=removeRedundantWhiteSpace(substitute(item,".","::")); 02017 current->fileName = yyFileName; 02018 //printf("Adding using directive: found:%s:%d name=%s\n",yyFileName.data(),yyLineNr,current->name.data()); 02019 current->section=Entry::USINGDIR_SEC; 02020 current_root->addSubEntry(current); 02021 current = new Entry ; 02022 initEntry(); 02023 BEGIN(Search); 02024 } 02025 YY_BREAK 02026 case 26: 02027 YY_RULE_SETUP 02028 #line 628 "pyscanner.l" 02029 { 02030 QCString item=g_packageName+"."+pyscanYYtext; 02031 current->name=removeRedundantWhiteSpace(substitute(item,".","::")); 02032 current->fileName = yyFileName; 02033 //printf("Adding using declaration: found:%s:%d name=%s\n",yyFileName.data(),yyLineNr,current->name.data()); 02034 current->section=Entry::USINGDECL_SEC; 02035 current_root->addSubEntry(current); 02036 current = new Entry ; 02037 initEntry(); 02038 BEGIN(Search); 02039 } 02040 YY_BREAK 02041 case 27: 02042 /* rule 27 can match eol */ 02043 YY_RULE_SETUP 02044 #line 639 "pyscanner.l" 02045 { 02046 yyLineNr++; 02047 BEGIN(Search); 02048 } 02049 YY_BREAK 02050 case 28: 02051 YY_RULE_SETUP 02052 #line 643 "pyscanner.l" 02053 { 02054 } 02055 YY_BREAK 02056 case 29: 02057 YY_RULE_SETUP 02058 #line 645 "pyscanner.l" 02059 { 02060 unput(*pyscanYYtext); 02061 BEGIN(Search); 02062 } 02063 YY_BREAK 02064 02065 02066 case 30: 02067 YY_RULE_SETUP 02068 #line 652 "pyscanner.l" 02069 { 02070 current->name=removeRedundantWhiteSpace(substitute(pyscanYYtext,".","::")); 02071 current->fileName = yyFileName; 02072 //printf("Adding using declaration: found:%s:%d name=%s\n",yyFileName.data(),yyLineNr,current->name.data()); 02073 current->section=Entry::USINGDECL_SEC; 02074 current_root->addSubEntry(current); 02075 current = new Entry ; 02076 initEntry(); 02077 BEGIN(Search); 02078 } 02079 YY_BREAK 02080 case 31: 02081 /* rule 31 can match eol */ 02082 YY_RULE_SETUP 02083 #line 662 "pyscanner.l" 02084 { 02085 yyLineNr++; 02086 BEGIN(Search); 02087 } 02088 YY_BREAK 02089 case 32: 02090 YY_RULE_SETUP 02091 #line 666 "pyscanner.l" 02092 { 02093 } 02094 YY_BREAK 02095 case 33: 02096 YY_RULE_SETUP 02097 #line 668 "pyscanner.l" 02098 { 02099 unput(*pyscanYYtext); 02100 BEGIN(Search); 02101 } 02102 YY_BREAK 02103 02104 02105 case 34: 02106 YY_RULE_SETUP 02107 #line 675 "pyscanner.l" 02108 { 02109 //printf("Found member variable %s in %s\n",&pyscanYYtext[5],current_root->name.data()); 02110 current->name=&pyscanYYtext[5]; 02111 current->section=Entry::VARIABLE_SEC; 02112 current->fileName = yyFileName; 02113 current->startLine = yyLineNr; 02114 current->bodyLine = yyLineNr; 02115 current->type.resize(0); 02116 if (current->name.at(0)=='_') // mark as private 02117 { 02118 current->protection=Private; 02119 } 02120 else 02121 { 02122 current->protection=Public; 02123 } 02124 newEntry(); 02125 } 02126 YY_BREAK 02127 case 35: 02128 YY_RULE_SETUP 02129 #line 693 "pyscanner.l" 02130 { // start of a comment block 02131 initTriDoubleQuoteBlock(); 02132 BEGIN(TripleComment); 02133 } 02134 YY_BREAK 02135 case 36: 02136 YY_RULE_SETUP 02137 #line 698 "pyscanner.l" 02138 { // start of a comment block 02139 initTriSingleQuoteBlock(); 02140 BEGIN(TripleComment); 02141 } 02142 YY_BREAK 02143 case 37: 02144 /* rule 37 can match eol */ 02145 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscanYYtext */ 02146 (yy_c_buf_p) = yy_cp -= 1; 02147 YY_DO_BEFORE_ACTION; /* set up pyscanYYtext again */ 02148 YY_RULE_SETUP 02149 #line 703 "pyscanner.l" 02150 { // start of a special comment 02151 initSpecialBlock(); 02152 BEGIN(SpecialComment); 02153 } 02154 YY_BREAK 02155 case 38: 02156 YY_RULE_SETUP 02157 #line 707 "pyscanner.l" 02158 { // # 02159 } 02160 YY_BREAK 02161 case 39: 02162 YY_RULE_SETUP 02163 #line 709 "pyscanner.l" 02164 { // start of a single quoted string 02165 g_stringContext=YY_START; 02166 g_copyString=0; 02167 BEGIN( SingleQuoteString ); 02168 } 02169 YY_BREAK 02170 case 40: 02171 YY_RULE_SETUP 02172 #line 714 "pyscanner.l" 02173 { // start of a double quoted string 02174 g_stringContext=YY_START; 02175 g_copyString=0; 02176 BEGIN( DoubleQuoteString ); 02177 } 02178 YY_BREAK 02179 case 41: 02180 /* rule 41 can match eol */ 02181 YY_RULE_SETUP 02182 #line 719 "pyscanner.l" 02183 { yyLineNr++; } 02184 YY_BREAK 02185 case 42: 02186 YY_RULE_SETUP 02187 #line 720 "pyscanner.l" 02188 // anything else 02189 YY_BREAK 02190 02191 02192 case 43: 02193 /* rule 43 can match eol */ 02194 YY_RULE_SETUP 02195 #line 724 "pyscanner.l" 02196 { 02197 //fprintf(stderr,"indent %d<=%d\n",computeIndent(&pyscanYYtext[1]),g_indent); 02198 if (computeIndent(&pyscanYYtext[1])<=g_indent) 02199 { 02200 int i; 02201 for (i=pyscanYYleng-1;i>=0;i--) 02202 { 02203 unput(pyscanYYtext[i]); 02204 } 02205 endOfDef(); 02206 YY_CURRENT_BUFFER->yy_at_bol=TRUE; 02207 BEGIN(Search); 02208 } 02209 else 02210 { 02211 yyLineNr++; 02212 current->program+=pyscanYYtext; 02213 } 02214 } 02215 YY_BREAK 02216 case 44: 02217 /* rule 44 can match eol */ 02218 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscanYYtext */ 02219 (yy_c_buf_p) = yy_cp -= 2; 02220 YY_DO_BEFORE_ACTION; /* set up pyscanYYtext again */ 02221 YY_RULE_SETUP 02222 #line 743 "pyscanner.l" 02223 { 02224 if (computeIndent(&pyscanYYtext[1])<=g_indent) 02225 { 02226 int i; 02227 for (i=pyscanYYleng-1;i>=0;i--) 02228 { 02229 unput(pyscanYYtext[i]); 02230 } 02231 endOfDef(); 02232 YY_CURRENT_BUFFER->yy_at_bol=TRUE; 02233 BEGIN(Search); 02234 } 02235 else 02236 { 02237 yyLineNr++; 02238 current->program+=pyscanYYtext; 02239 } 02240 } 02241 YY_BREAK 02242 case YY_STATE_EOF(FunctionBody): 02243 #line 761 "pyscanner.l" 02244 { 02245 endOfDef(); 02246 yyterminate(); 02247 } 02248 YY_BREAK 02249 case 45: 02250 /* rule 45 can match eol */ 02251 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscanYYtext */ 02252 (yy_c_buf_p) = yy_cp -= 1; 02253 YY_DO_BEFORE_ACTION; /* set up pyscanYYtext again */ 02254 YY_RULE_SETUP 02255 #line 765 "pyscanner.l" 02256 { // skip empty line 02257 current->program+=pyscanYYtext; 02258 } 02259 YY_BREAK 02260 case 46: 02261 YY_RULE_SETUP 02262 #line 768 "pyscanner.l" 02263 { // something at indent >0 02264 current->program+=pyscanYYtext; 02265 g_curIndent = computeIndent(pyscanYYtext); 02266 if (g_curIndent<=g_indent) 02267 // jumped out of the function 02268 { 02269 endOfDef(); 02270 BEGIN(Search); 02271 } 02272 } 02273 YY_BREAK 02274 case 47: 02275 YY_RULE_SETUP 02276 #line 778 "pyscanner.l" 02277 { // start of a single quoted string 02278 current->program+=pyscanYYtext; 02279 g_stringContext=YY_START; 02280 g_specialBlock = FALSE; 02281 g_copyString=¤t->program; 02282 BEGIN( SingleQuoteString ); 02283 } 02284 YY_BREAK 02285 case 48: 02286 YY_RULE_SETUP 02287 #line 785 "pyscanner.l" 02288 { // start of a double quoted string 02289 current->program+=pyscanYYtext; 02290 g_stringContext=YY_START; 02291 g_specialBlock = FALSE; 02292 g_copyString=¤t->program; 02293 BEGIN( DoubleQuoteString ); 02294 } 02295 YY_BREAK 02296 case 49: 02297 YY_RULE_SETUP 02298 #line 792 "pyscanner.l" 02299 { // non-special stuff 02300 current->program+=pyscanYYtext; 02301 g_specialBlock = FALSE; 02302 } 02303 YY_BREAK 02304 case 50: 02305 YY_RULE_SETUP 02306 #line 796 "pyscanner.l" 02307 { // normal comment 02308 current->program+=pyscanYYtext; 02309 } 02310 YY_BREAK 02311 case 51: 02312 YY_RULE_SETUP 02313 #line 799 "pyscanner.l" 02314 { // comment half way 02315 current->program+=pyscanYYtext; 02316 } 02317 YY_BREAK 02318 case 52: 02319 /* rule 52 can match eol */ 02320 YY_RULE_SETUP 02321 #line 802 "pyscanner.l" 02322 { yyLineNr++; 02323 current->program+=pyscanYYtext; 02324 } 02325 YY_BREAK 02326 case 53: 02327 YY_RULE_SETUP 02328 #line 805 "pyscanner.l" 02329 { // any character 02330 current->program+=*pyscanYYtext; 02331 g_specialBlock = FALSE; 02332 } 02333 YY_BREAK 02334 case 54: 02335 YY_RULE_SETUP 02336 #line 810 "pyscanner.l" 02337 { // start of a comment block 02338 current->program+=pyscanYYtext; 02339 initTriDoubleQuoteBlock(); 02340 BEGIN(TripleComment); 02341 } 02342 YY_BREAK 02343 case 55: 02344 YY_RULE_SETUP 02345 #line 816 "pyscanner.l" 02346 { // start of a comment block 02347 current->program+=pyscanYYtext; 02348 initTriSingleQuoteBlock(); 02349 BEGIN(TripleComment); 02350 } 02351 YY_BREAK 02352 case 56: 02353 /* rule 56 can match eol */ 02354 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscanYYtext */ 02355 (yy_c_buf_p) = yy_cp -= 1; 02356 YY_DO_BEFORE_ACTION; /* set up pyscanYYtext again */ 02357 YY_RULE_SETUP 02358 #line 822 "pyscanner.l" 02359 { // start of a special comment 02360 initSpecialBlock(); 02361 BEGIN(SpecialComment); 02362 } 02363 YY_BREAK 02364 02365 02366 case 57: 02367 YY_RULE_SETUP 02368 #line 831 "pyscanner.l" 02369 { 02370 //found function name 02371 if (current->type.isEmpty()) 02372 { 02373 current->type = "def"; 02374 } 02375 current->name = pyscanYYtext; 02376 current->name = current->name.stripWhiteSpace(); 02377 newFunction(); 02378 } 02379 YY_BREAK 02380 case 58: 02381 YY_RULE_SETUP 02382 #line 841 "pyscanner.l" 02383 { // function without arguments 02384 g_specialBlock = TRUE; // expecting a docstring 02385 bodyEntry = current; 02386 BEGIN( FunctionBody ); 02387 } 02388 YY_BREAK 02389 case 59: 02390 YY_RULE_SETUP 02391 #line 847 "pyscanner.l" 02392 { 02393 BEGIN( FunctionParams ); 02394 } 02395 YY_BREAK 02396 02397 02398 case 60: 02399 YY_RULE_SETUP 02400 #line 853 "pyscanner.l" 02401 { 02402 } 02403 YY_BREAK 02404 case 61: 02405 YY_RULE_SETUP 02406 #line 856 "pyscanner.l" 02407 { // Name of parameter 02408 lineCount(); 02409 Argument *a = new Argument; 02410 current->argList->append(a); 02411 current->argList->getLast()->name = QCString(pyscanYYtext).stripWhiteSpace(); 02412 current->argList->getLast()->type = ""; 02413 } 02414 YY_BREAK 02415 case 62: 02416 YY_RULE_SETUP 02417 #line 863 "pyscanner.l" 02418 { // default value 02419 // TODO: this rule is too simple, need to be able to 02420 // match things like =")" as well! 02421 QCString defVal=&pyscanYYtext[1]; 02422 g_defVal.resize(0); 02423 g_braceCount=0; 02424 BEGIN(FunctionParamDefVal); 02425 } 02426 YY_BREAK 02427 case 63: 02428 YY_RULE_SETUP 02429 #line 872 "pyscanner.l" 02430 { // end of parameter list 02431 } 02432 YY_BREAK 02433 case 64: 02434 YY_RULE_SETUP 02435 #line 875 "pyscanner.l" 02436 { 02437 g_specialBlock = TRUE; // expecting a docstring 02438 bodyEntry = current; 02439 BEGIN( FunctionBody ); 02440 } 02441 YY_BREAK 02442 case 65: 02443 YY_RULE_SETUP 02444 #line 880 "pyscanner.l" 02445 { // a comment 02446 } 02447 YY_BREAK 02448 case 66: 02449 YY_RULE_SETUP 02450 #line 882 "pyscanner.l" 02451 { // Default rule inside arguments. 02452 } 02453 YY_BREAK 02454 02455 02456 case 67: 02457 YY_RULE_SETUP 02458 #line 888 "pyscanner.l" 02459 { // internal opening brace 02460 g_braceCount++; 02461 g_defVal+=*pyscanYYtext; 02462 } 02463 YY_BREAK 02464 case 68: 02465 #line 893 "pyscanner.l" 02466 case 69: 02467 YY_RULE_SETUP 02468 #line 893 "pyscanner.l" 02469 { 02470 if (g_braceCount==0) // end of default argument 02471 { 02472 if (current->argList->getLast()) 02473 { 02474 current->argList->getLast()->defval=g_defVal.stripWhiteSpace(); 02475 } 02476 BEGIN(FunctionParams); 02477 } 02478 else // continue 02479 { 02480 g_braceCount--; 02481 g_defVal+=*pyscanYYtext; 02482 } 02483 } 02484 YY_BREAK 02485 case 70: 02486 YY_RULE_SETUP 02487 #line 908 "pyscanner.l" 02488 { 02489 g_defVal+=*pyscanYYtext; 02490 } 02491 YY_BREAK 02492 case 71: 02493 /* rule 71 can match eol */ 02494 YY_RULE_SETUP 02495 #line 911 "pyscanner.l" 02496 { 02497 g_defVal+=*pyscanYYtext; 02498 yyLineNr++; 02499 } 02500 YY_BREAK 02501 02502 02503 case 72: 02504 /* rule 72 can match eol */ 02505 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscanYYtext */ 02506 (yy_c_buf_p) = yy_cp = yy_bp + 1; 02507 YY_DO_BEFORE_ACTION; /* set up pyscanYYtext again */ 02508 YY_RULE_SETUP 02509 #line 919 "pyscanner.l" 02510 { // new def at indent 0 02511 yyLineNr++; 02512 endOfDef(); 02513 g_hideClassDocs = FALSE; 02514 YY_CURRENT_BUFFER->yy_at_bol=TRUE; 02515 BEGIN(Search); 02516 } 02517 YY_BREAK 02518 case 73: 02519 /* rule 73 can match eol */ 02520 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscanYYtext */ 02521 (yy_c_buf_p) = yy_cp = yy_bp + 1; 02522 YY_DO_BEFORE_ACTION; /* set up pyscanYYtext again */ 02523 YY_RULE_SETUP 02524 #line 926 "pyscanner.l" 02525 { // start of a special comment at indent 0 02526 yyLineNr++; 02527 endOfDef(); 02528 g_hideClassDocs = FALSE; 02529 YY_CURRENT_BUFFER->yy_at_bol=TRUE; 02530 BEGIN(Search); 02531 } 02532 YY_BREAK 02533 case 74: 02534 /* rule 74 can match eol */ 02535 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscanYYtext */ 02536 (yy_c_buf_p) = yy_cp -= 1; 02537 YY_DO_BEFORE_ACTION; /* set up pyscanYYtext again */ 02538 YY_RULE_SETUP 02539 #line 933 "pyscanner.l" 02540 { // skip empty line 02541 current->program+=pyscanYYtext; 02542 } 02543 YY_BREAK 02544 case YY_STATE_EOF(ClassBody): 02545 #line 936 "pyscanner.l" 02546 { 02547 endOfDef(); 02548 yyterminate(); 02549 } 02550 YY_BREAK 02551 case 75: 02552 YY_RULE_SETUP 02553 #line 940 "pyscanner.l" 02554 { // something at indent >0 02555 g_curIndent=computeIndent(pyscanYYtext); 02556 //fprintf(stderr,"g_curIndent=%d g_indent=%d\n",g_curIndent,g_indent); 02557 if (g_curIndent<=g_indent) 02558 // jumped out of the class 02559 { 02560 endOfDef(); 02561 g_indent=g_curIndent; 02562 // make sure the next rule matches ^... 02563 YY_CURRENT_BUFFER->yy_at_bol=TRUE; 02564 g_hideClassDocs = FALSE; 02565 BEGIN(Search); 02566 } 02567 else 02568 { 02569 current->program+=pyscanYYtext; 02570 } 02571 } 02572 YY_BREAK 02573 case 76: 02574 YY_RULE_SETUP 02575 #line 958 "pyscanner.l" 02576 { // start of a single quoted string 02577 current->program+=*pyscanYYtext; 02578 g_stringContext=YY_START; 02579 g_specialBlock = FALSE; 02580 g_copyString=¤t->program; 02581 BEGIN( SingleQuoteString ); 02582 } 02583 YY_BREAK 02584 case 77: 02585 YY_RULE_SETUP 02586 #line 965 "pyscanner.l" 02587 { // start of a double quoted string 02588 current->program+=*pyscanYYtext; 02589 g_stringContext=YY_START; 02590 g_specialBlock = FALSE; 02591 g_copyString=¤t->program; 02592 BEGIN( DoubleQuoteString ); 02593 } 02594 YY_BREAK 02595 case 78: 02596 YY_RULE_SETUP 02597 #line 972 "pyscanner.l" 02598 { // non-special stuff 02599 current->program+=pyscanYYtext; 02600 g_specialBlock = FALSE; 02601 g_hideClassDocs = FALSE; 02602 } 02603 YY_BREAK 02604 case 79: 02605 /* rule 79 can match eol */ 02606 YY_RULE_SETUP 02607 #line 977 "pyscanner.l" 02608 { 02609 current->program+=*pyscanYYtext; 02610 yyLineNr++; 02611 } 02612 YY_BREAK 02613 case 80: 02614 YY_RULE_SETUP 02615 #line 981 "pyscanner.l" 02616 { // normal comment 02617 current->program+=pyscanYYtext; 02618 } 02619 YY_BREAK 02620 case 81: 02621 YY_RULE_SETUP 02622 #line 984 "pyscanner.l" 02623 { // any character 02624 g_specialBlock = FALSE; 02625 current->program+=*pyscanYYtext; 02626 } 02627 YY_BREAK 02628 case 82: 02629 YY_RULE_SETUP 02630 #line 988 "pyscanner.l" 02631 { // start of a comment block 02632 if (!g_hideClassDocs) current->program+=pyscanYYtext; 02633 initTriDoubleQuoteBlock(); 02634 BEGIN(TripleComment); 02635 } 02636 YY_BREAK 02637 case 83: 02638 YY_RULE_SETUP 02639 #line 994 "pyscanner.l" 02640 { // start of a comment block 02641 if (!g_hideClassDocs) current->program+=pyscanYYtext; 02642 initTriSingleQuoteBlock(); 02643 BEGIN(TripleComment); 02644 } 02645 YY_BREAK 02646 02647 case 84: 02648 YY_RULE_SETUP 02649 #line 1001 "pyscanner.l" 02650 { 02651 if (current->type.isEmpty()) 02652 { 02653 current->type = "class"; 02654 } 02655 02656 current->section = Entry::CLASS_SEC; 02657 current->name = pyscanYYtext; 02658 02659 // prepend scope in case of nested classes 02660 if (current_root->section&Entry::SCOPE_MASK) 02661 { 02662 //printf("*** Prepending scope %s to class %s\n",current_root->name.data(),current->name.data()); 02663 current->name.prepend(current_root->name+"::"); 02664 } 02665 02666 current->name = current->name.stripWhiteSpace(); 02667 current->fileName = yyFileName; 02668 docBlockContext = YY_START; 02669 docBlockInBody = FALSE; 02670 docBlockJavaStyle = FALSE; 02671 docBlock.resize(0); 02672 02673 BEGIN(ClassInheritance); 02674 } 02675 YY_BREAK 02676 02677 case 85: 02678 YY_RULE_SETUP 02679 #line 1028 "pyscanner.l" 02680 { // syntactic sugar for the list 02681 } 02682 YY_BREAK 02683 case 86: 02684 YY_RULE_SETUP 02685 #line 1031 "pyscanner.l" 02686 { // begin of the class definition 02687 g_specialBlock = TRUE; // expecting a docstring 02688 BEGIN(ClassCaptureIndent); 02689 } 02690 YY_BREAK 02691 case 87: 02692 YY_RULE_SETUP 02693 #line 1036 "pyscanner.l" 02694 { 02695 current->extends->append( 02696 new BaseInfo(substitute(pyscanYYtext,".","::"),Public,Normal) 02697 ); 02698 //Has base class-do stuff 02699 } 02700 YY_BREAK 02701 02702 02703 case 88: 02704 /* rule 88 can match eol */ 02705 YY_RULE_SETUP 02706 #line 1046 "pyscanner.l" 02707 { 02708 // Blankline - ignore, keep looking for indentation. 02709 lineCount(); 02710 } 02711 YY_BREAK 02712 case 89: 02713 YY_RULE_SETUP 02714 #line 1051 "pyscanner.l" 02715 { // start of a comment block 02716 initTriDoubleQuoteBlock(); 02717 BEGIN(TripleComment); 02718 } 02719 YY_BREAK 02720 case 90: 02721 YY_RULE_SETUP 02722 #line 1056 "pyscanner.l" 02723 { // start of a comment block 02724 initTriSingleQuoteBlock(); 02725 BEGIN(TripleComment); 02726 } 02727 YY_BREAK 02728 case 91: 02729 YY_RULE_SETUP 02730 #line 1061 "pyscanner.l" 02731 { 02732 current->program=pyscanYYtext; 02733 current->startLine = yyLineNr; 02734 g_curIndent=computeIndent(pyscanYYtext); 02735 bodyEntry = current; 02736 //fprintf(stderr,"setting indent %d\n",g_curIndent); 02737 //printf("current->program=[%s]\n",current->program.data()); 02738 g_hideClassDocs = TRUE; 02739 BEGIN(ClassBody); 02740 } 02741 YY_BREAK 02742 case 92: 02743 YY_RULE_SETUP 02744 #line 1072 "pyscanner.l" 02745 { 02746 02747 // Just pushback an empty class, and 02748 // resume parsing the body. 02749 newEntry(); 02750 02751 // printf("Failed to find indent - skipping!"); 02752 BEGIN( Search ); 02753 } 02754 YY_BREAK 02755 02756 02757 case 93: 02758 YY_RULE_SETUP 02759 #line 1085 "pyscanner.l" 02760 { // the assignment operator 02761 //printf("====== VariableDec at line %d\n",yyLineNr); 02762 } 02763 YY_BREAK 02764 case 94: 02765 YY_RULE_SETUP 02766 #line 1088 "pyscanner.l" 02767 { // spaces 02768 } 02769 YY_BREAK 02770 case 95: 02771 YY_RULE_SETUP 02772 #line 1090 "pyscanner.l" 02773 { // integer value 02774 current->type = "int"; 02775 current->initializer = pyscanYYtext; 02776 BEGIN(VariableEnd); 02777 } 02778 YY_BREAK 02779 case 96: 02780 YY_RULE_SETUP 02781 #line 1095 "pyscanner.l" 02782 { // floating point value 02783 current->type = "float"; 02784 current->initializer = pyscanYYtext; 02785 BEGIN(VariableEnd); 02786 } 02787 YY_BREAK 02788 case 97: 02789 YY_RULE_SETUP 02790 #line 1100 "pyscanner.l" 02791 { // string 02792 current->type = "string"; 02793 current->initializer = pyscanYYtext; 02794 g_copyString=¤t->initializer; 02795 g_stringContext=VariableEnd; 02796 BEGIN( SingleQuoteString ); 02797 } 02798 YY_BREAK 02799 case 98: 02800 YY_RULE_SETUP 02801 #line 1107 "pyscanner.l" 02802 { // string 02803 current->type = "string"; 02804 current->initializer = pyscanYYtext; 02805 g_copyString=¤t->initializer; 02806 g_stringContext=VariableEnd; 02807 BEGIN( DoubleQuoteString ); 02808 } 02809 YY_BREAK 02810 case 99: 02811 YY_RULE_SETUP 02812 #line 1114 "pyscanner.l" 02813 { // start of a comment block 02814 current->type = "string"; 02815 current->initializer = pyscanYYtext; 02816 g_doubleQuote=TRUE; 02817 g_copyString=¤t->initializer; 02818 g_stringContext=VariableEnd; 02819 BEGIN(TripleString); 02820 } 02821 YY_BREAK 02822 case 100: 02823 YY_RULE_SETUP 02824 #line 1123 "pyscanner.l" 02825 { // start of a comment block 02826 current->type = "string"; 02827 current->initializer = pyscanYYtext; 02828 g_doubleQuote=FALSE; 02829 g_copyString=¤t->initializer; 02830 g_stringContext=VariableEnd; 02831 BEGIN(TripleString); 02832 } 02833 YY_BREAK 02834 case 101: 02835 YY_RULE_SETUP 02836 #line 1131 "pyscanner.l" 02837 { // tuple 02838 current->type = "tuple"; 02839 current->initializer+=*pyscanYYtext; 02840 g_atomStart='('; 02841 g_atomEnd=')'; 02842 g_atomCount=1; 02843 BEGIN( VariableAtom ); 02844 } 02845 YY_BREAK 02846 case 102: 02847 YY_RULE_SETUP 02848 #line 1139 "pyscanner.l" 02849 { // list 02850 current->type = "list"; 02851 current->initializer+=*pyscanYYtext; 02852 g_atomStart='['; 02853 g_atomEnd=']'; 02854 g_atomCount=1; 02855 BEGIN( VariableAtom ); 02856 } 02857 YY_BREAK 02858 case 103: 02859 YY_RULE_SETUP 02860 #line 1147 "pyscanner.l" 02861 { // dictionary 02862 current->type = "dictionary"; 02863 current->initializer+=*pyscanYYtext; 02864 g_atomStart='{'; 02865 g_atomEnd='}'; 02866 g_atomCount=1; 02867 BEGIN( VariableAtom ); 02868 } 02869 YY_BREAK 02870 case 104: 02871 YY_RULE_SETUP 02872 #line 1155 "pyscanner.l" 02873 { // comment 02874 BEGIN( VariableEnd ); 02875 } 02876 YY_BREAK 02877 case 105: 02878 YY_RULE_SETUP 02879 #line 1158 "pyscanner.l" 02880 { 02881 current->initializer+=pyscanYYtext; 02882 } 02883 YY_BREAK 02884 case 106: 02885 YY_RULE_SETUP 02886 #line 1161 "pyscanner.l" 02887 { 02888 current->initializer+=*pyscanYYtext; 02889 } 02890 YY_BREAK 02891 case 107: 02892 /* rule 107 can match eol */ 02893 YY_RULE_SETUP 02894 #line 1164 "pyscanner.l" 02895 { 02896 unput('\n'); 02897 BEGIN( VariableEnd ); 02898 } 02899 YY_BREAK 02900 02901 02902 case 108: 02903 YY_RULE_SETUP 02904 #line 1171 "pyscanner.l" 02905 { 02906 current->initializer+=*pyscanYYtext; 02907 if (g_atomStart==*pyscanYYtext) 02908 { 02909 g_atomCount++; 02910 } 02911 } 02912 YY_BREAK 02913 case 109: 02914 YY_RULE_SETUP 02915 #line 1178 "pyscanner.l" 02916 { 02917 current->initializer+=*pyscanYYtext; 02918 if (g_atomEnd==*pyscanYYtext) 02919 { 02920 g_atomCount--; 02921 } 02922 if (g_atomCount==0) 02923 { 02924 BEGIN(VariableEnd); 02925 } 02926 } 02927 YY_BREAK 02928 case 110: 02929 YY_RULE_SETUP 02930 #line 1189 "pyscanner.l" 02931 { 02932 g_stringContext=YY_START; 02933 current->initializer+="\""; 02934 g_copyString=¤t->initializer; 02935 BEGIN( DoubleQuoteString ); 02936 } 02937 YY_BREAK 02938 case 111: 02939 YY_RULE_SETUP 02940 #line 1195 "pyscanner.l" 02941 { 02942 current->initializer+=pyscanYYtext; 02943 } 02944 YY_BREAK 02945 case 112: 02946 YY_RULE_SETUP 02947 #line 1198 "pyscanner.l" 02948 { 02949 current->initializer+=*pyscanYYtext; 02950 } 02951 YY_BREAK 02952 case 113: 02953 /* rule 113 can match eol */ 02954 YY_RULE_SETUP 02955 #line 1201 "pyscanner.l" 02956 { 02957 current->initializer+=*pyscanYYtext; 02958 yyLineNr++; 02959 } 02960 YY_BREAK 02961 02962 02963 case 114: 02964 /* rule 114 can match eol */ 02965 YY_RULE_SETUP 02966 #line 1209 "pyscanner.l" 02967 { 02968 yyLineNr++; 02969 newVariable(); 02970 BEGIN(Search); 02971 } 02972 YY_BREAK 02973 case 115: 02974 YY_RULE_SETUP 02975 #line 1214 "pyscanner.l" 02976 { 02977 unput(*pyscanYYtext); 02978 newVariable(); 02979 BEGIN(Search); 02980 } 02981 YY_BREAK 02982 case YY_STATE_EOF(VariableEnd): 02983 #line 1219 "pyscanner.l" 02984 { yyterminate(); 02985 newEntry(); 02986 } 02987 YY_BREAK 02988 02989 02990 case 116: 02991 #line 1226 "pyscanner.l" 02992 case 117: 02993 YY_RULE_SETUP 02994 #line 1226 "pyscanner.l" 02995 { 02996 // printf("Expected module block %d special=%d\n",g_expectModuleDocs,g_specialBlock); 02997 if (g_doubleQuote==(pyscanYYtext[0]=='"')) 02998 { 02999 if (g_specialBlock) // expecting a docstring 03000 { 03001 QCString actualDoc=docBlock; 03002 if (!docBlockSpecial) // legacy unformatted docstring 03003 { 03004 actualDoc.prepend("\\verbatim "); 03005 actualDoc.append("\\endverbatim "); 03006 } 03007 //printf("-------> current=%p bodyEntry=%p\n",current,bodyEntry); 03008 handleCommentBlock(actualDoc, FALSE); 03009 } 03010 else if (g_packageCommentAllowed) // expecting module docs 03011 { 03012 QCString actualDoc=docBlock; 03013 if (!docBlockSpecial) // legacy unformatted docstring 03014 { 03015 actualDoc.prepend("\\verbatim "); 03016 actualDoc.append("\\endverbatim "); 03017 } 03018 actualDoc.prepend("\\namespace "+g_moduleScope+"\\_linebr "); 03019 handleCommentBlock(actualDoc, FALSE); 03020 } 03021 if ((docBlockContext==ClassBody && !g_hideClassDocs) || 03022 docBlockContext==FunctionBody) 03023 { 03024 current->program+=docBlock; 03025 current->program+=pyscanYYtext; 03026 } 03027 if (g_hideClassDocs) 03028 current->startLine = yyLineNr; 03029 g_hideClassDocs=FALSE; 03030 BEGIN(docBlockContext); 03031 } 03032 else 03033 { 03034 docBlock += pyscanYYtext; 03035 } 03036 g_packageCommentAllowed = FALSE; 03037 } 03038 YY_BREAK 03039 case 118: 03040 YY_RULE_SETUP 03041 #line 1271 "pyscanner.l" 03042 { // leading whitespace 03043 int indent = computeIndent(pyscanYYtext); 03044 if (indent>=g_curIndent) 03045 { // strip g_curIndent amount of whitespace 03046 int i; 03047 for (i=0;i<indent-g_curIndent;i++) docBlock+=' '; 03048 //fprintf(stderr,"stripping indent %d\n",g_curIndent); 03049 } 03050 else 03051 { 03052 //fprintf(stderr,"not stripping: %d<%d\n",indent,g_curIndent); 03053 docBlock += pyscanYYtext; 03054 } 03055 } 03056 YY_BREAK 03057 case 119: 03058 YY_RULE_SETUP 03059 #line 1285 "pyscanner.l" 03060 { 03061 docBlock += pyscanYYtext; 03062 } 03063 YY_BREAK 03064 case 120: 03065 /* rule 120 can match eol */ 03066 YY_RULE_SETUP 03067 #line 1288 "pyscanner.l" 03068 { 03069 yyLineNr++; 03070 docBlock += pyscanYYtext; 03071 } 03072 YY_BREAK 03073 case 121: 03074 YY_RULE_SETUP 03075 #line 1292 "pyscanner.l" 03076 { 03077 docBlock += pyscanYYtext; 03078 } 03079 YY_BREAK 03080 03081 03082 case 122: 03083 YY_RULE_SETUP 03084 #line 1298 "pyscanner.l" 03085 { // skip leading hashes 03086 } 03087 YY_BREAK 03088 case 123: 03089 /* rule 123 can match eol */ 03090 *yy_cp = (yy_hold_char); /* undo effects of setting up pyscanYYtext */ 03091 (yy_c_buf_p) = yy_cp = yy_bp + 1; 03092 YY_DO_BEFORE_ACTION; /* set up pyscanYYtext again */ 03093 YY_RULE_SETUP 03094 #line 1300 "pyscanner.l" 03095 { // continuation of the comment on the next line 03096 docBlock+='\n'; 03097 docBrief = FALSE; 03098 startCommentBlock(FALSE); 03099 yyLineNr++; 03100 } 03101 YY_BREAK 03102 case 124: 03103 YY_RULE_SETUP 03104 #line 1306 "pyscanner.l" 03105 { // any other stuff 03106 docBlock+=pyscanYYtext; 03107 } 03108 YY_BREAK 03109 case 125: 03110 /* rule 125 can match eol */ 03111 YY_RULE_SETUP 03112 #line 1309 "pyscanner.l" 03113 { // new line that ends the comment 03114 handleCommentBlock(docBlock, docBrief); 03115 yyLineNr++; 03116 BEGIN(docBlockContext); 03117 } 03118 YY_BREAK 03119 case 126: 03120 YY_RULE_SETUP 03121 #line 1314 "pyscanner.l" 03122 { // anything we missed 03123 docBlock+=*pyscanYYtext; 03124 } 03125 YY_BREAK 03126 03127 03128 case 127: 03129 /* rule 127 can match eol */ 03130 YY_RULE_SETUP 03131 #line 1320 "pyscanner.l" 03132 { // line continuation 03133 addToString(pyscanYYtext); 03134 yyLineNr++; 03135 } 03136 YY_BREAK 03137 case 128: 03138 YY_RULE_SETUP 03139 #line 1324 "pyscanner.l" 03140 { // espaced char 03141 addToString(pyscanYYtext); 03142 } 03143 YY_BREAK 03144 case 129: 03145 YY_RULE_SETUP 03146 #line 1327 "pyscanner.l" 03147 { // tripple double quotes 03148 addToString(pyscanYYtext); 03149 } 03150 YY_BREAK 03151 case 130: 03152 YY_RULE_SETUP 03153 #line 1330 "pyscanner.l" 03154 { // end of the string 03155 addToString(pyscanYYtext); 03156 BEGIN(g_stringContext); 03157 } 03158 YY_BREAK 03159 case 131: 03160 YY_RULE_SETUP 03161 #line 1334 "pyscanner.l" 03162 { // normal chars 03163 addToString(pyscanYYtext); 03164 } 03165 YY_BREAK 03166 case 132: 03167 YY_RULE_SETUP 03168 #line 1337 "pyscanner.l" 03169 { // normal char 03170 addToString(pyscanYYtext); 03171 } 03172 YY_BREAK 03173 03174 03175 case 133: 03176 /* rule 133 can match eol */ 03177 YY_RULE_SETUP 03178 #line 1343 "pyscanner.l" 03179 { // line continuation 03180 addToString(pyscanYYtext); 03181 yyLineNr++; 03182 } 03183 YY_BREAK 03184 case 134: 03185 YY_RULE_SETUP 03186 #line 1347 "pyscanner.l" 03187 { // espaced char 03188 addToString(pyscanYYtext); 03189 } 03190 YY_BREAK 03191 case 135: 03192 YY_RULE_SETUP 03193 #line 1350 "pyscanner.l" 03194 { // tripple single quotes 03195 addToString(pyscanYYtext); 03196 } 03197 YY_BREAK 03198 case 136: 03199 YY_RULE_SETUP 03200 #line 1353 "pyscanner.l" 03201 { // end of the string 03202 addToString(pyscanYYtext); 03203 BEGIN(g_stringContext); 03204 } 03205 YY_BREAK 03206 case 137: 03207 YY_RULE_SETUP 03208 #line 1357 "pyscanner.l" 03209 { // normal chars 03210 addToString(pyscanYYtext); 03211 } 03212 YY_BREAK 03213 case 138: 03214 YY_RULE_SETUP 03215 #line 1360 "pyscanner.l" 03216 { // normal char 03217 addToString(pyscanYYtext); 03218 } 03219 YY_BREAK 03220 03221 03222 case 139: 03223 #line 1367 "pyscanner.l" 03224 case 140: 03225 YY_RULE_SETUP 03226 #line 1367 "pyscanner.l" 03227 { 03228 *g_copyString += pyscanYYtext; 03229 if (g_doubleQuote==(pyscanYYtext[0]=='"')) 03230 { 03231 BEGIN(g_stringContext); 03232 } 03233 } 03234 YY_BREAK 03235 case 141: 03236 /* rule 141 can match eol */ 03237 YY_RULE_SETUP 03238 #line 1376 "pyscanner.l" 03239 { 03240 lineCount(); 03241 *g_copyString += pyscanYYtext; 03242 } 03243 YY_BREAK 03244 case 142: 03245 /* rule 142 can match eol */ 03246 YY_RULE_SETUP 03247 #line 1380 "pyscanner.l" 03248 { 03249 yyLineNr++; 03250 *g_copyString += pyscanYYtext; 03251 } 03252 YY_BREAK 03253 case 143: 03254 YY_RULE_SETUP 03255 #line 1384 "pyscanner.l" 03256 { 03257 *g_copyString += *pyscanYYtext; 03258 } 03259 YY_BREAK 03260 03261 /* ------------ End rules -------------- */ 03262 /* 03263 <*>({NONEMPTY}|{EXPCHAR}|{BB}) { // This should go one character at a time. 03264 // printf("[pyscanner] '%s' [ state %d ] [line %d] no match\n", 03265 // pyscanYYtext, YY_START, yyLineNr); 03266 03267 } 03268 */ 03269 case 144: 03270 /* rule 144 can match eol */ 03271 YY_RULE_SETUP 03272 #line 1399 "pyscanner.l" 03273 { 03274 //printf("[pyscanner] %d NEWLINE [line %d] no match\n", 03275 // YY_START, yyLineNr); 03276 03277 lineCount(); 03278 } 03279 YY_BREAK 03280 case 145: 03281 YY_RULE_SETUP 03282 #line 1406 "pyscanner.l" 03283 { 03284 //printf("[pyscanner] '%s' [ state %d ] [line %d] no match\n", 03285 // pyscanYYtext, YY_START, yyLineNr); 03286 03287 } 03288 YY_BREAK 03289 case 146: 03290 YY_RULE_SETUP 03291 #line 1413 "pyscanner.l" 03292 ECHO; 03293 YY_BREAK 03294 #line 3295 "<stdout>" 03295 case YY_STATE_EOF(INITIAL): 03296 case YY_STATE_EOF(Search): 03297 case YY_STATE_EOF(SearchMemVars): 03298 case YY_STATE_EOF(TryClassDocString): 03299 case YY_STATE_EOF(TripleComment): 03300 case YY_STATE_EOF(SpecialComment): 03301 case YY_STATE_EOF(FunctionDec): 03302 case YY_STATE_EOF(FunctionParams): 03303 case YY_STATE_EOF(FunctionParamDefVal): 03304 case YY_STATE_EOF(ClassDec): 03305 case YY_STATE_EOF(ClassInheritance): 03306 case YY_STATE_EOF(ClassCaptureIndent): 03307 case YY_STATE_EOF(VariableDec): 03308 case YY_STATE_EOF(VariableAtom): 03309 case YY_STATE_EOF(SingleQuoteString): 03310 case YY_STATE_EOF(DoubleQuoteString): 03311 case YY_STATE_EOF(TripleString): 03312 case YY_STATE_EOF(FromMod): 03313 case YY_STATE_EOF(FromModItem): 03314 case YY_STATE_EOF(Import): 03315 yyterminate(); 03316 03317 case YY_END_OF_BUFFER: 03318 { 03319 /* Amount of text matched not including the EOB char. */ 03320 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; 03321 03322 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 03323 *yy_cp = (yy_hold_char); 03324 YY_RESTORE_YY_MORE_OFFSET 03325 03326 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 03327 { 03328 /* We're scanning a new file or input source. It's 03329 * possible that this happened because the user 03330 * just pointed pyscanYYin at a new source and called 03331 * pyscanYYlex(). If so, then we have to assure 03332 * consistency between YY_CURRENT_BUFFER and our 03333 * globals. Here is the right place to do so, because 03334 * this is the first action (other than possibly a 03335 * back-up) that will match for the new input source. 03336 */ 03337 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 03338 YY_CURRENT_BUFFER_LVALUE->yy_input_file = pyscanYYin; 03339 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 03340 } 03341 03342 /* Note that here we test for yy_c_buf_p "<=" to the position 03343 * of the first EOB in the buffer, since yy_c_buf_p will 03344 * already have been incremented past the NUL character 03345 * (since all states make transitions on EOB to the 03346 * end-of-buffer state). Contrast this with the test 03347 * in input(). 03348 */ 03349 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 03350 { /* This was really a NUL. */ 03351 yy_state_type yy_next_state; 03352 03353 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; 03354 03355 yy_current_state = yy_get_previous_state( ); 03356 03357 /* Okay, we're now positioned to make the NUL 03358 * transition. We couldn't have 03359 * yy_get_previous_state() go ahead and do it 03360 * for us because it doesn't know how to deal 03361 * with the possibility of jamming (and we don't 03362 * want to build jamming into it because then it 03363 * will run more slowly). 03364 */ 03365 03366 yy_next_state = yy_try_NUL_trans( yy_current_state ); 03367 03368 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 03369 03370 if ( yy_next_state ) 03371 { 03372 /* Consume the NUL. */ 03373 yy_cp = ++(yy_c_buf_p); 03374 yy_current_state = yy_next_state; 03375 goto yy_match; 03376 } 03377 03378 else 03379 { 03380 yy_cp = (yy_c_buf_p); 03381 goto yy_find_action; 03382 } 03383 } 03384 03385 else switch ( yy_get_next_buffer( ) ) 03386 { 03387 case EOB_ACT_END_OF_FILE: 03388 { 03389 (yy_did_buffer_switch_on_eof) = 0; 03390 03391 if ( pyscanYYwrap( ) ) 03392 { 03393 /* Note: because we've taken care in 03394 * yy_get_next_buffer() to have set up 03395 * pyscanYYtext, we can now set up 03396 * yy_c_buf_p so that if some total 03397 * hoser (like flex itself) wants to 03398 * call the scanner after we return the 03399 * YY_NULL, it'll still work - another 03400 * YY_NULL will get returned. 03401 */ 03402 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; 03403 03404 yy_act = YY_STATE_EOF(YY_START); 03405 goto do_action; 03406 } 03407 03408 else 03409 { 03410 if ( ! (yy_did_buffer_switch_on_eof) ) 03411 YY_NEW_FILE; 03412 } 03413 break; 03414 } 03415 03416 case EOB_ACT_CONTINUE_SCAN: 03417 (yy_c_buf_p) = 03418 (yytext_ptr) + yy_amount_of_matched_text; 03419 03420 yy_current_state = yy_get_previous_state( ); 03421 03422 yy_cp = (yy_c_buf_p); 03423 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 03424 goto yy_match; 03425 03426 case EOB_ACT_LAST_MATCH: 03427 (yy_c_buf_p) = 03428 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; 03429 03430 yy_current_state = yy_get_previous_state( ); 03431 03432 yy_cp = (yy_c_buf_p); 03433 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 03434 goto yy_find_action; 03435 } 03436 break; 03437 } 03438 03439 default: 03440 YY_FATAL_ERROR( 03441 "fatal flex scanner internal error--no action found" ); 03442 } /* end of action switch */ 03443 } /* end of scanning one token */ 03444 } /* end of pyscanYYlex */ 03445 03446 /* yy_get_next_buffer - try to read in a new buffer 03447 * 03448 * Returns a code representing an action: 03449 * EOB_ACT_LAST_MATCH - 03450 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 03451 * EOB_ACT_END_OF_FILE - end of file 03452 */ 03453 static int yy_get_next_buffer (void) 03454 { 03455 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 03456 register char *source = (yytext_ptr); 03457 register int number_to_move, i; 03458 int ret_val; 03459 03460 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) 03461 YY_FATAL_ERROR( 03462 "fatal flex scanner internal error--end of buffer missed" ); 03463 03464 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 03465 { /* Don't try to fill the buffer, so this is an EOF. */ 03466 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) 03467 { 03468 /* We matched a single character, the EOB, so 03469 * treat this as a final EOF. 03470 */ 03471 return EOB_ACT_END_OF_FILE; 03472 } 03473 03474 else 03475 { 03476 /* We matched some text prior to the EOB, first 03477 * process it. 03478 */ 03479 return EOB_ACT_LAST_MATCH; 03480 } 03481 } 03482 03483 /* Try to read more data. */ 03484 03485 /* First move last chars to start of buffer. */ 03486 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; 03487 03488 for ( i = 0; i < number_to_move; ++i ) 03489 *(dest++) = *(source++); 03490 03491 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 03492 /* don't do the read, it's not guaranteed to return an EOF, 03493 * just force an EOF 03494 */ 03495 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; 03496 03497 else 03498 { 03499 int num_to_read = 03500 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 03501 03502 while ( num_to_read <= 0 ) 03503 { /* Not enough room in the buffer - grow it. */ 03504 03505 YY_FATAL_ERROR( 03506 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 03507 03508 } 03509 03510 if ( num_to_read > YY_READ_BUF_SIZE ) 03511 num_to_read = YY_READ_BUF_SIZE; 03512 03513 /* Read in more data. */ 03514 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 03515 (yy_n_chars), num_to_read ); 03516 03517 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 03518 } 03519 03520 if ( (yy_n_chars) == 0 ) 03521 { 03522 if ( number_to_move == YY_MORE_ADJ ) 03523 { 03524 ret_val = EOB_ACT_END_OF_FILE; 03525 pyscanYYrestart(pyscanYYin ); 03526 } 03527 03528 else 03529 { 03530 ret_val = EOB_ACT_LAST_MATCH; 03531 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 03532 YY_BUFFER_EOF_PENDING; 03533 } 03534 } 03535 03536 else 03537 ret_val = EOB_ACT_CONTINUE_SCAN; 03538 03539 (yy_n_chars) += number_to_move; 03540 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; 03541 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; 03542 03543 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 03544 03545 return ret_val; 03546 } 03547 03548 /* yy_get_previous_state - get the state just before the EOB char was reached */ 03549 03550 static yy_state_type yy_get_previous_state (void) 03551 { 03552 register yy_state_type yy_current_state; 03553 register char *yy_cp; 03554 03555 yy_current_state = (yy_start); 03556 yy_current_state += YY_AT_BOL(); 03557 03558 (yy_state_ptr) = (yy_state_buf); 03559 *(yy_state_ptr)++ = yy_current_state; 03560 03561 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) 03562 { 03563 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 03564 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 03565 { 03566 yy_current_state = (int) yy_def[yy_current_state]; 03567 if ( yy_current_state >= 437 ) 03568 yy_c = yy_meta[(unsigned int) yy_c]; 03569 } 03570 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 03571 *(yy_state_ptr)++ = yy_current_state; 03572 } 03573 03574 return yy_current_state; 03575 } 03576 03577 /* yy_try_NUL_trans - try to make a transition on the NUL character 03578 * 03579 * synopsis 03580 * next_state = yy_try_NUL_trans( current_state ); 03581 */ 03582 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) 03583 { 03584 register int yy_is_jam; 03585 03586 register YY_CHAR yy_c = 1; 03587 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 03588 { 03589 yy_current_state = (int) yy_def[yy_current_state]; 03590 if ( yy_current_state >= 437 ) 03591 yy_c = yy_meta[(unsigned int) yy_c]; 03592 } 03593 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 03594 yy_is_jam = (yy_current_state == 436); 03595 if ( ! yy_is_jam ) 03596 *(yy_state_ptr)++ = yy_current_state; 03597 03598 return yy_is_jam ? 0 : yy_current_state; 03599 } 03600 03601 static void yyunput (int c, register char * yy_bp ) 03602 { 03603 register char *yy_cp; 03604 03605 yy_cp = (yy_c_buf_p); 03606 03607 /* undo effects of setting up pyscanYYtext */ 03608 *yy_cp = (yy_hold_char); 03609 03610 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 03611 { /* need to shift things up to make room */ 03612 /* +2 for EOB chars. */ 03613 register int number_to_move = (yy_n_chars) + 2; 03614 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ 03615 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; 03616 register char *source = 03617 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; 03618 03619 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 03620 *--dest = *--source; 03621 03622 yy_cp += (int) (dest - source); 03623 yy_bp += (int) (dest - source); 03624 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = 03625 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; 03626 03627 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 03628 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 03629 } 03630 03631 *--yy_cp = (char) c; 03632 03633 (yytext_ptr) = yy_bp; 03634 (yy_hold_char) = *yy_cp; 03635 (yy_c_buf_p) = yy_cp; 03636 } 03637 03638 #ifndef YY_NO_INPUT 03639 #ifdef __cplusplus 03640 static int yyinput (void) 03641 #else 03642 static int input (void) 03643 #endif 03644 03645 { 03646 int c; 03647 03648 *(yy_c_buf_p) = (yy_hold_char); 03649 03650 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) 03651 { 03652 /* yy_c_buf_p now points to the character we want to return. 03653 * If this occurs *before* the EOB characters, then it's a 03654 * valid NUL; if not, then we've hit the end of the buffer. 03655 */ 03656 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 03657 /* This was really a NUL. */ 03658 *(yy_c_buf_p) = '\0'; 03659 03660 else 03661 { /* need more input */ 03662 int offset = (yy_c_buf_p) - (yytext_ptr); 03663 ++(yy_c_buf_p); 03664 03665 switch ( yy_get_next_buffer( ) ) 03666 { 03667 case EOB_ACT_LAST_MATCH: 03668 /* This happens because yy_g_n_b() 03669 * sees that we've accumulated a 03670 * token and flags that we need to 03671 * try matching the token before 03672 * proceeding. But for input(), 03673 * there's no matching to consider. 03674 * So convert the EOB_ACT_LAST_MATCH 03675 * to EOB_ACT_END_OF_FILE. 03676 */ 03677 03678 /* Reset buffer status. */ 03679 pyscanYYrestart(pyscanYYin ); 03680 03681 /*FALLTHROUGH*/ 03682 03683 case EOB_ACT_END_OF_FILE: 03684 { 03685 if ( pyscanYYwrap( ) ) 03686 return 0; 03687 03688 if ( ! (yy_did_buffer_switch_on_eof) ) 03689 YY_NEW_FILE; 03690 #ifdef __cplusplus 03691 return yyinput(); 03692 #else 03693 return input(); 03694 #endif 03695 } 03696 03697 case EOB_ACT_CONTINUE_SCAN: 03698 (yy_c_buf_p) = (yytext_ptr) + offset; 03699 break; 03700 } 03701 } 03702 } 03703 03704 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ 03705 *(yy_c_buf_p) = '\0'; /* preserve pyscanYYtext */ 03706 (yy_hold_char) = *++(yy_c_buf_p); 03707 03708 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n'); 03709 03710 return c; 03711 } 03712 #endif /* ifndef YY_NO_INPUT */ 03713 03719 void pyscanYYrestart (FILE * input_file ) 03720 { 03721 03722 if ( ! YY_CURRENT_BUFFER ){ 03723 pyscanYYensure_buffer_stack (); 03724 YY_CURRENT_BUFFER_LVALUE = 03725 pyscanYY_create_buffer(pyscanYYin,YY_BUF_SIZE ); 03726 } 03727 03728 pyscanYY_init_buffer(YY_CURRENT_BUFFER,input_file ); 03729 pyscanYY_load_buffer_state( ); 03730 } 03731 03736 void pyscanYY_switch_to_buffer (YY_BUFFER_STATE new_buffer ) 03737 { 03738 03739 /* TODO. We should be able to replace this entire function body 03740 * with 03741 * pyscanYYpop_buffer_state(); 03742 * pyscanYYpush_buffer_state(new_buffer); 03743 */ 03744 pyscanYYensure_buffer_stack (); 03745 if ( YY_CURRENT_BUFFER == new_buffer ) 03746 return; 03747 03748 if ( YY_CURRENT_BUFFER ) 03749 { 03750 /* Flush out information for old buffer. */ 03751 *(yy_c_buf_p) = (yy_hold_char); 03752 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 03753 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 03754 } 03755 03756 YY_CURRENT_BUFFER_LVALUE = new_buffer; 03757 pyscanYY_load_buffer_state( ); 03758 03759 /* We don't actually know whether we did this switch during 03760 * EOF (pyscanYYwrap()) processing, but the only time this flag 03761 * is looked at is after pyscanYYwrap() is called, so it's safe 03762 * to go ahead and always set it. 03763 */ 03764 (yy_did_buffer_switch_on_eof) = 1; 03765 } 03766 03767 static void pyscanYY_load_buffer_state (void) 03768 { 03769 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 03770 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 03771 pyscanYYin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 03772 (yy_hold_char) = *(yy_c_buf_p); 03773 } 03774 03781 YY_BUFFER_STATE pyscanYY_create_buffer (FILE * file, int size ) 03782 { 03783 YY_BUFFER_STATE b; 03784 03785 b = (YY_BUFFER_STATE) pyscanYYalloc(sizeof( struct yy_buffer_state ) ); 03786 if ( ! b ) 03787 YY_FATAL_ERROR( "out of dynamic memory in pyscanYY_create_buffer()" ); 03788 03789 b->yy_buf_size = size; 03790 03791 /* yy_ch_buf has to be 2 characters longer than the size given because 03792 * we need to put in 2 end-of-buffer characters. 03793 */ 03794 b->yy_ch_buf = (char *) pyscanYYalloc(b->yy_buf_size + 2 ); 03795 if ( ! b->yy_ch_buf ) 03796 YY_FATAL_ERROR( "out of dynamic memory in pyscanYY_create_buffer()" ); 03797 03798 b->yy_is_our_buffer = 1; 03799 03800 pyscanYY_init_buffer(b,file ); 03801 03802 return b; 03803 } 03804 03809 void pyscanYY_delete_buffer (YY_BUFFER_STATE b ) 03810 { 03811 03812 if ( ! b ) 03813 return; 03814 03815 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 03816 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 03817 03818 if ( b->yy_is_our_buffer ) 03819 pyscanYYfree((void *) b->yy_ch_buf ); 03820 03821 pyscanYYfree((void *) b ); 03822 } 03823 03824 #ifndef __cplusplus 03825 extern int isatty (int ); 03826 #endif /* __cplusplus */ 03827 03828 /* Initializes or reinitializes a buffer. 03829 * This function is sometimes called more than once on the same buffer, 03830 * such as during a pyscanYYrestart() or at EOF. 03831 */ 03832 static void pyscanYY_init_buffer (YY_BUFFER_STATE b, FILE * file ) 03833 03834 { 03835 int oerrno = errno; 03836 03837 pyscanYY_flush_buffer(b ); 03838 03839 b->yy_input_file = file; 03840 b->yy_fill_buffer = 1; 03841 03842 /* If b is the current buffer, then pyscanYY_init_buffer was _probably_ 03843 * called from pyscanYYrestart() or through yy_get_next_buffer. 03844 * In that case, we don't want to reset the lineno or column. 03845 */ 03846 if (b != YY_CURRENT_BUFFER){ 03847 b->yy_bs_lineno = 1; 03848 b->yy_bs_column = 0; 03849 } 03850 03851 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 03852 03853 errno = oerrno; 03854 } 03855 03860 void pyscanYY_flush_buffer (YY_BUFFER_STATE b ) 03861 { 03862 if ( ! b ) 03863 return; 03864 03865 b->yy_n_chars = 0; 03866 03867 /* We always need two end-of-buffer characters. The first causes 03868 * a transition to the end-of-buffer state. The second causes 03869 * a jam in that state. 03870 */ 03871 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 03872 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 03873 03874 b->yy_buf_pos = &b->yy_ch_buf[0]; 03875 03876 b->yy_at_bol = 1; 03877 b->yy_buffer_status = YY_BUFFER_NEW; 03878 03879 if ( b == YY_CURRENT_BUFFER ) 03880 pyscanYY_load_buffer_state( ); 03881 } 03882 03889 void pyscanYYpush_buffer_state (YY_BUFFER_STATE new_buffer ) 03890 { 03891 if (new_buffer == NULL) 03892 return; 03893 03894 pyscanYYensure_buffer_stack(); 03895 03896 /* This block is copied from pyscanYY_switch_to_buffer. */ 03897 if ( YY_CURRENT_BUFFER ) 03898 { 03899 /* Flush out information for old buffer. */ 03900 *(yy_c_buf_p) = (yy_hold_char); 03901 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 03902 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 03903 } 03904 03905 /* Only push if top exists. Otherwise, replace top. */ 03906 if (YY_CURRENT_BUFFER) 03907 (yy_buffer_stack_top)++; 03908 YY_CURRENT_BUFFER_LVALUE = new_buffer; 03909 03910 /* copied from pyscanYY_switch_to_buffer. */ 03911 pyscanYY_load_buffer_state( ); 03912 (yy_did_buffer_switch_on_eof) = 1; 03913 } 03914 03919 void pyscanYYpop_buffer_state (void) 03920 { 03921 if (!YY_CURRENT_BUFFER) 03922 return; 03923 03924 pyscanYY_delete_buffer(YY_CURRENT_BUFFER ); 03925 YY_CURRENT_BUFFER_LVALUE = NULL; 03926 if ((yy_buffer_stack_top) > 0) 03927 --(yy_buffer_stack_top); 03928 03929 if (YY_CURRENT_BUFFER) { 03930 pyscanYY_load_buffer_state( ); 03931 (yy_did_buffer_switch_on_eof) = 1; 03932 } 03933 } 03934 03935 /* Allocates the stack if it does not exist. 03936 * Guarantees space for at least one push. 03937 */ 03938 static void pyscanYYensure_buffer_stack (void) 03939 { 03940 int num_to_alloc; 03941 03942 if (!(yy_buffer_stack)) { 03943 03944 /* First allocation is just for 2 elements, since we don't know if this 03945 * scanner will even need a stack. We use 2 instead of 1 to avoid an 03946 * immediate realloc on the next call. 03947 */ 03948 num_to_alloc = 1; 03949 (yy_buffer_stack) = (struct yy_buffer_state**)pyscanYYalloc 03950 (num_to_alloc * sizeof(struct yy_buffer_state*) 03951 ); 03952 03953 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 03954 03955 (yy_buffer_stack_max) = num_to_alloc; 03956 (yy_buffer_stack_top) = 0; 03957 return; 03958 } 03959 03960 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ 03961 03962 /* Increase the buffer to prepare for a possible push. */ 03963 int grow_size = 8 /* arbitrary grow size */; 03964 03965 num_to_alloc = (yy_buffer_stack_max) + grow_size; 03966 (yy_buffer_stack) = (struct yy_buffer_state**)pyscanYYrealloc 03967 ((yy_buffer_stack), 03968 num_to_alloc * sizeof(struct yy_buffer_state*) 03969 ); 03970 03971 /* zero only the new slots.*/ 03972 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 03973 (yy_buffer_stack_max) = num_to_alloc; 03974 } 03975 } 03976 03983 YY_BUFFER_STATE pyscanYY_scan_buffer (char * base, yy_size_t size ) 03984 { 03985 YY_BUFFER_STATE b; 03986 03987 if ( size < 2 || 03988 base[size-2] != YY_END_OF_BUFFER_CHAR || 03989 base[size-1] != YY_END_OF_BUFFER_CHAR ) 03990 /* They forgot to leave room for the EOB's. */ 03991 return 0; 03992 03993 b = (YY_BUFFER_STATE) pyscanYYalloc(sizeof( struct yy_buffer_state ) ); 03994 if ( ! b ) 03995 YY_FATAL_ERROR( "out of dynamic memory in pyscanYY_scan_buffer()" ); 03996 03997 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 03998 b->yy_buf_pos = b->yy_ch_buf = base; 03999 b->yy_is_our_buffer = 0; 04000 b->yy_input_file = 0; 04001 b->yy_n_chars = b->yy_buf_size; 04002 b->yy_is_interactive = 0; 04003 b->yy_at_bol = 1; 04004 b->yy_fill_buffer = 0; 04005 b->yy_buffer_status = YY_BUFFER_NEW; 04006 04007 pyscanYY_switch_to_buffer(b ); 04008 04009 return b; 04010 } 04011 04020 YY_BUFFER_STATE pyscanYY_scan_string (yyconst char * yystr ) 04021 { 04022 04023 return pyscanYY_scan_bytes(yystr,strlen(yystr) ); 04024 } 04025 04033 YY_BUFFER_STATE pyscanYY_scan_bytes (yyconst char * yybytes, int _yybytes_len ) 04034 { 04035 YY_BUFFER_STATE b; 04036 char *buf; 04037 yy_size_t n; 04038 int i; 04039 04040 /* Get memory for full buffer, including space for trailing EOB's. */ 04041 n = _yybytes_len + 2; 04042 buf = (char *) pyscanYYalloc(n ); 04043 if ( ! buf ) 04044 YY_FATAL_ERROR( "out of dynamic memory in pyscanYY_scan_bytes()" ); 04045 04046 for ( i = 0; i < _yybytes_len; ++i ) 04047 buf[i] = yybytes[i]; 04048 04049 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 04050 04051 b = pyscanYY_scan_buffer(buf,n ); 04052 if ( ! b ) 04053 YY_FATAL_ERROR( "bad buffer in pyscanYY_scan_bytes()" ); 04054 04055 /* It's okay to grow etc. this buffer, and we should throw it 04056 * away when we're done. 04057 */ 04058 b->yy_is_our_buffer = 1; 04059 04060 return b; 04061 } 04062 04063 #ifndef YY_EXIT_FAILURE 04064 #define YY_EXIT_FAILURE 2 04065 #endif 04066 04067 static void yy_fatal_error (yyconst char* msg ) 04068 { 04069 (void) fprintf( stderr, "%s\n", msg ); 04070 exit( YY_EXIT_FAILURE ); 04071 } 04072 04073 /* Redefine yyless() so it works in section 3 code. */ 04074 04075 #undef yyless 04076 #define yyless(n) \ 04077 do \ 04078 { \ 04079 /* Undo effects of setting up pyscanYYtext. */ \ 04080 int yyless_macro_arg = (n); \ 04081 YY_LESS_LINENO(yyless_macro_arg);\ 04082 pyscanYYtext[pyscanYYleng] = (yy_hold_char); \ 04083 (yy_c_buf_p) = pyscanYYtext + yyless_macro_arg; \ 04084 (yy_hold_char) = *(yy_c_buf_p); \ 04085 *(yy_c_buf_p) = '\0'; \ 04086 pyscanYYleng = yyless_macro_arg; \ 04087 } \ 04088 while ( 0 ) 04089 04090 /* Accessor methods (get/set functions) to struct members. */ 04091 04095 int pyscanYYget_lineno (void) 04096 { 04097 04098 return pyscanYYlineno; 04099 } 04100 04104 FILE *pyscanYYget_in (void) 04105 { 04106 return pyscanYYin; 04107 } 04108 04112 FILE *pyscanYYget_out (void) 04113 { 04114 return pyscanYYout; 04115 } 04116 04120 int pyscanYYget_leng (void) 04121 { 04122 return pyscanYYleng; 04123 } 04124 04129 char *pyscanYYget_text (void) 04130 { 04131 return pyscanYYtext; 04132 } 04133 04138 void pyscanYYset_lineno (int line_number ) 04139 { 04140 04141 pyscanYYlineno = line_number; 04142 } 04143 04150 void pyscanYYset_in (FILE * in_str ) 04151 { 04152 pyscanYYin = in_str ; 04153 } 04154 04155 void pyscanYYset_out (FILE * out_str ) 04156 { 04157 pyscanYYout = out_str ; 04158 } 04159 04160 int pyscanYYget_debug (void) 04161 { 04162 return pyscanYY_flex_debug; 04163 } 04164 04165 void pyscanYYset_debug (int bdebug ) 04166 { 04167 pyscanYY_flex_debug = bdebug ; 04168 } 04169 04170 static int yy_init_globals (void) 04171 { 04172 /* Initialization is the same as for the non-reentrant scanner. 04173 * This function is called from pyscanYYlex_destroy(), so don't allocate here. 04174 */ 04175 04176 (yy_buffer_stack) = 0; 04177 (yy_buffer_stack_top) = 0; 04178 (yy_buffer_stack_max) = 0; 04179 (yy_c_buf_p) = (char *) 0; 04180 (yy_init) = 0; 04181 (yy_start) = 0; 04182 04183 (yy_state_buf) = 0; 04184 (yy_state_ptr) = 0; 04185 (yy_full_match) = 0; 04186 (yy_lp) = 0; 04187 04188 /* Defined in main.c */ 04189 #ifdef YY_STDINIT 04190 pyscanYYin = stdin; 04191 pyscanYYout = stdout; 04192 #else 04193 pyscanYYin = (FILE *) 0; 04194 pyscanYYout = (FILE *) 0; 04195 #endif 04196 04197 /* For future reference: Set errno on error, since we are called by 04198 * pyscanYYlex_init() 04199 */ 04200 return 0; 04201 } 04202 04203 /* pyscanYYlex_destroy is for both reentrant and non-reentrant scanners. */ 04204 int pyscanYYlex_destroy (void) 04205 { 04206 04207 /* Pop the buffer stack, destroying each element. */ 04208 while(YY_CURRENT_BUFFER){ 04209 pyscanYY_delete_buffer(YY_CURRENT_BUFFER ); 04210 YY_CURRENT_BUFFER_LVALUE = NULL; 04211 pyscanYYpop_buffer_state(); 04212 } 04213 04214 /* Destroy the stack itself. */ 04215 pyscanYYfree((yy_buffer_stack) ); 04216 (yy_buffer_stack) = NULL; 04217 04218 pyscanYYfree ( (yy_state_buf) ); 04219 (yy_state_buf) = NULL; 04220 04221 /* Reset the globals. This is important in a non-reentrant scanner so the next time 04222 * pyscanYYlex() is called, initialization will occur. */ 04223 yy_init_globals( ); 04224 04225 return 0; 04226 } 04227 04228 /* 04229 * Internal utility routines. 04230 */ 04231 04232 #ifndef yytext_ptr 04233 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) 04234 { 04235 register int i; 04236 for ( i = 0; i < n; ++i ) 04237 s1[i] = s2[i]; 04238 } 04239 #endif 04240 04241 #ifdef YY_NEED_STRLEN 04242 static int yy_flex_strlen (yyconst char * s ) 04243 { 04244 register int n; 04245 for ( n = 0; s[n]; ++n ) 04246 ; 04247 04248 return n; 04249 } 04250 #endif 04251 04252 void *pyscanYYalloc (yy_size_t size ) 04253 { 04254 return (void *) malloc( size ); 04255 } 04256 04257 void *pyscanYYrealloc (void * ptr, yy_size_t size ) 04258 { 04259 /* The cast to (char *) in the following accommodates both 04260 * implementations that use char* generic pointers, and those 04261 * that use void* generic pointers. It works with the latter 04262 * because both ANSI C and C++ allow castless assignment from 04263 * any pointer type to void*, and deal with argument conversions 04264 * as though doing an assignment. 04265 */ 04266 return (void *) realloc( (char *) ptr, size ); 04267 } 04268 04269 void pyscanYYfree (void * ptr ) 04270 { 04271 free( (char *) ptr ); /* see pyscanYYrealloc() for (char *) cast */ 04272 } 04273 04274 #define YYTABLES_NAME "yytables" 04275 04276 #line 1413 "pyscanner.l" 04277 04278 04279 04280 //---------------------------------------------------------------------------- 04281 04282 static void parseCompounds(Entry *rt) 04283 { 04284 //printf("parseCompounds(%s)\n",rt->name.data()); 04285 EntryListIterator eli(*rt->children()); 04286 Entry *ce; 04287 for (;(ce=eli.current());++eli) 04288 { 04289 if (!ce->program.isEmpty()) 04290 { 04291 //printf("-- %s ---------\n%s\n---------------\n", 04292 // ce->name.data(),ce->program.data()); 04293 // init scanner state 04294 inputString = ce->program; 04295 inputPosition = 0; 04296 pyscanYYrestart( pyscanYYin ) ; 04297 if (ce->section&Entry::COMPOUND_MASK) 04298 { 04299 current_root = ce ; 04300 BEGIN( Search ); 04301 } 04302 else if (ce->parent()) 04303 { 04304 current_root = ce->parent(); 04305 //printf("Searching for member variables in %s parent=%s\n", 04306 // ce->name.data(),ce->parent->name.data()); 04307 BEGIN( SearchMemVars ); 04308 } 04309 yyFileName = ce->fileName; 04310 yyLineNr = ce->startLine ; 04311 if (current) delete current; 04312 current = new Entry; 04313 04314 groupEnterCompound(yyFileName,yyLineNr,ce->name); 04315 04316 pyscanYYlex() ; 04317 g_lexInit=TRUE; 04318 delete current; current=0; 04319 ce->program.resize(0); 04320 04321 groupLeaveCompound(yyFileName,yyLineNr,ce->name); 04322 04323 } 04324 parseCompounds(ce); 04325 } 04326 } 04327 04328 //---------------------------------------------------------------------------- 04329 04330 04331 static void parseMain(const char *fileName,const char *fileBuf,Entry *rt) 04332 { 04333 initParser(); 04334 04335 inputString = fileBuf; 04336 inputPosition = 0; 04337 04338 protection = Public; 04339 mtype = Method; 04340 gstat = FALSE; 04341 virt = Normal; 04342 current_root = rt; 04343 g_specialBlock = FALSE; 04344 04345 04346 inputFile.setName(fileName); 04347 if (inputFile.open(IO_ReadOnly)) 04348 { 04349 yyLineNr= 1 ; 04350 yyFileName = fileName; 04351 //setContext(); 04352 msg("Parsing file %s...\n",yyFileName.data()); 04353 04354 QFileInfo fi(fileName); 04355 g_moduleScope = findPackageScope(fileName); 04356 QString baseName=fi.baseName(); 04357 if (baseName!="__init__") // package initializer file is not a package itself 04358 { 04359 if (!g_moduleScope.isEmpty()) 04360 { 04361 g_moduleScope+="::"; 04362 } 04363 g_moduleScope+=baseName; 04364 } 04365 04366 current = new Entry; 04367 current->name = g_moduleScope; 04368 current->section = Entry::NAMESPACE_SEC; 04369 current->type = "namespace"; 04370 current->fileName = yyFileName; 04371 current->startLine = yyLineNr; 04372 current->bodyLine = yyLineNr; 04373 04374 rt->addSubEntry(current); 04375 04376 current_root = current ; 04377 initParser(); 04378 current = new Entry; 04379 04380 groupEnterFile(yyFileName,yyLineNr); 04381 04382 current->reset(); 04383 pyscanYYrestart( pyscanYYin ); 04384 BEGIN( Search ); 04385 pyscanYYlex(); 04386 g_lexInit=TRUE; 04387 04388 groupLeaveFile(yyFileName,yyLineNr); 04389 04390 current_root->program.resize(0); 04391 delete current; current=0; 04392 04393 parseCompounds(current_root); 04394 04395 inputFile.close(); 04396 } 04397 04398 } 04399 04400 //---------------------------------------------------------------------------- 04401 04402 static void parsePrototype(const QCString &text) 04403 { 04404 //printf("**** parsePrototype(%s) begin\n",text.data()); 04405 if (text.isEmpty()) 04406 { 04407 warn(yyFileName,yyLineNr,"Empty prototype found!"); 04408 return; 04409 } 04410 04411 g_specialBlock = FALSE; 04412 g_packageCommentAllowed = FALSE; 04413 04414 const char *orgInputString; 04415 int orgInputPosition; 04416 YY_BUFFER_STATE orgState; 04417 04418 // save scanner state 04419 orgState = YY_CURRENT_BUFFER; 04420 pyscanYY_switch_to_buffer(pyscanYY_create_buffer(pyscanYYin,YY_BUF_SIZE)); 04421 orgInputString = inputString; 04422 orgInputPosition = inputPosition; 04423 04424 // set new string 04425 inputString = text; 04426 inputPosition = 0; 04427 pyscanYYrestart( pyscanYYin ); 04428 04429 BEGIN( FunctionDec ); 04430 04431 pyscanYYlex(); 04432 g_lexInit=TRUE; 04433 04434 current->name = current->name.stripWhiteSpace(); 04435 if (current->section == Entry::MEMBERDOC_SEC && current->args.isEmpty()) 04436 current->section = Entry::VARIABLEDOC_SEC; 04437 04438 // restore original scanner state 04439 04440 YY_BUFFER_STATE tmpBuf = YY_CURRENT_BUFFER; 04441 pyscanYY_switch_to_buffer(orgState); 04442 pyscanYY_delete_buffer(tmpBuf); 04443 04444 inputString = orgInputString; 04445 inputPosition = orgInputPosition; 04446 04447 //printf("**** parsePrototype end\n"); 04448 } 04449 04450 void pyscanFreeScanner() 04451 { 04452 #if defined(YY_FLEX_SUBMINOR_VERSION) 04453 if (g_lexInit) 04454 { 04455 pyscanYYlex_destroy(); 04456 } 04457 #endif 04458 } 04459 04460 //---------------------------------------------------------------------------- 04461 04462 void PythonLanguageScanner::parseInput(const char *fileName,const char *fileBuf,Entry *root) 04463 { 04464 g_thisParser = this; 04465 ::parseMain(fileName,fileBuf,root); 04466 04467 // May print the AST for debugging purposes 04468 // printAST(global_root); 04469 } 04470 04471 bool PythonLanguageScanner::needsPreprocessing(const QCString &) 04472 { 04473 return FALSE; 04474 } 04475 04476 void PythonLanguageScanner::parseCode(CodeOutputInterface &codeOutIntf, 04477 const char *scopeName, 04478 const QCString &input, 04479 bool isExampleBlock, 04480 const char *exampleName, 04481 FileDef *fileDef, 04482 int startLine, 04483 int endLine, 04484 bool inlineFragment, 04485 MemberDef *memberDef 04486 ) 04487 { 04488 ::parsePythonCode(codeOutIntf,scopeName,input,isExampleBlock,exampleName, 04489 fileDef,startLine,endLine,inlineFragment,memberDef); 04490 } 04491 04492 void PythonLanguageScanner::parsePrototype(const char *text) 04493 { 04494 ::parsePrototype(text); 04495 04496 } 04497 04498 void PythonLanguageScanner::resetCodeParserState() 04499 { 04500 ::resetPythonCodeParserState(); 04501 } 04502 04503 //---------------------------------------------------------------------------- 04504 04505 #if !defined(YY_FLEX_SUBMINOR_VERSION) 04506 //---------------------------------------------------------------------------- 04507 extern "C" { // some bogus code to keep the compiler happy 04508 void pyscannerYYdummy() { yy_flex_realloc(0,0); } 04509 } 04510 #endif 04511 04512
1.5.1