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 pycodeYYrestart(pycodeYYin ) 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 pycodeYYleng; 00155 00156 extern FILE *pycodeYYin, *pycodeYYout; 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 pycodeYYtext. */ \ 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 pycodeYYtext 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 pycodeYYrestart()), so that the user can continue scanning by 00248 * just pointing pycodeYYin 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 pycodeYYtext is formed. */ 00276 static char yy_hold_char; 00277 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 00278 int pycodeYYleng; 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 pycodeYYwrap()'s to do buffer switches 00286 * instead of setting up a fresh pycodeYYin. A bit of a hack ... 00287 */ 00288 static int yy_did_buffer_switch_on_eof; 00289 00290 void pycodeYYrestart (FILE *input_file ); 00291 void pycodeYY_switch_to_buffer (YY_BUFFER_STATE new_buffer ); 00292 YY_BUFFER_STATE pycodeYY_create_buffer (FILE *file,int size ); 00293 void pycodeYY_delete_buffer (YY_BUFFER_STATE b ); 00294 void pycodeYY_flush_buffer (YY_BUFFER_STATE b ); 00295 void pycodeYYpush_buffer_state (YY_BUFFER_STATE new_buffer ); 00296 void pycodeYYpop_buffer_state (void ); 00297 00298 static void pycodeYYensure_buffer_stack (void ); 00299 static void pycodeYY_load_buffer_state (void ); 00300 static void pycodeYY_init_buffer (YY_BUFFER_STATE b,FILE *file ); 00301 00302 #define YY_FLUSH_BUFFER pycodeYY_flush_buffer(YY_CURRENT_BUFFER ) 00303 00304 YY_BUFFER_STATE pycodeYY_scan_buffer (char *base,yy_size_t size ); 00305 YY_BUFFER_STATE pycodeYY_scan_string (yyconst char *yy_str ); 00306 YY_BUFFER_STATE pycodeYY_scan_bytes (yyconst char *bytes,int len ); 00307 00308 void *pycodeYYalloc (yy_size_t ); 00309 void *pycodeYYrealloc (void *,yy_size_t ); 00310 void pycodeYYfree (void * ); 00311 00312 #define yy_new_buffer pycodeYY_create_buffer 00313 00314 #define yy_set_interactive(is_interactive) \ 00315 { \ 00316 if ( ! YY_CURRENT_BUFFER ){ \ 00317 pycodeYYensure_buffer_stack (); \ 00318 YY_CURRENT_BUFFER_LVALUE = \ 00319 pycodeYY_create_buffer(pycodeYYin,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 pycodeYYensure_buffer_stack (); \ 00328 YY_CURRENT_BUFFER_LVALUE = \ 00329 pycodeYY_create_buffer(pycodeYYin,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 pycodeYYwrap(n) 1 00339 #define YY_SKIP_YYWRAP 00340 00341 typedef unsigned char YY_CHAR; 00342 00343 FILE *pycodeYYin = (FILE *) 0, *pycodeYYout = (FILE *) 0; 00344 00345 typedef int yy_state_type; 00346 00347 extern int pycodeYYlineno; 00348 00349 int pycodeYYlineno = 1; 00350 00351 extern char *pycodeYYtext; 00352 #define yytext_ptr pycodeYYtext 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 pycodeYYtext. 00361 */ 00362 #define YY_DO_BEFORE_ACTION \ 00363 (yytext_ptr) = yy_bp; \ 00364 pycodeYYleng = (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 56 00370 #define YY_END_OF_BUFFER 57 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[909] = 00379 { 0, 00380 16412,16412, 57, 55, 56, 54, 56, 52, 55, 56, 00381 53, 55, 56, 51, 55, 56, 55, 56, 55, 56, 00382 55, 56, 31, 54, 56, 17, 30, 55, 56, 17, 00383 30, 55, 56, 17, 30, 55, 56, 17, 30, 55, 00384 56, 17, 30, 55, 56, 17, 30, 55, 56, 17, 00385 30, 55, 56, 17, 30, 55, 56, 17, 30, 55, 00386 56, 17, 30, 55, 56, 17, 30, 55, 56, 17, 00387 30, 55, 56, 17, 30, 55, 56, 17, 30, 55, 00388 56, 17, 30, 55, 56, 17, 30, 55, 56, 17, 00389 30, 55, 56, 17, 30, 55, 56, 17, 30, 55, 00390 00391 56, 17, 30, 55, 56, 17, 30, 55, 56, 17, 00392 30, 55, 56, 17, 30, 55, 56, 17, 30, 55, 00393 56, 55, 56, 10, 55, 56, 9, 55, 56, 9, 00394 55, 56, 9, 55, 56, 9, 55, 56, 12, 55, 00395 56, 11, 55, 56, 12, 52, 55, 56, 12, 53, 00396 55, 56, 12, 51, 55, 56, 13, 55, 56, 11, 00397 12, 55, 56, 14, 55, 56, 12, 55, 56, 12, 00398 55, 56, 12, 55, 56, 12, 55, 56, 5, 55, 00399 56, 5, 55, 56, 5, 55, 56, 5, 55, 56, 00400 6, 55, 56, 6, 55, 56, 8, 55, 56, 7, 00401 00402 55, 56, 7, 55, 56, 7, 55, 56, 7, 55, 00403 56, 29, 54, 56, 17, 55, 56, 17, 55, 56, 00404 17, 55, 56, 17, 55, 56, 17, 55, 56, 17, 00405 55, 56, 17, 55, 56, 17, 55, 56, 17, 55, 00406 56, 17, 55, 56, 17, 55, 56, 17, 55, 56, 00407 17, 55, 56, 17, 55, 56, 17, 55, 56, 17, 00408 55, 56, 17, 55, 56, 17, 55, 56, 17, 55, 00409 56, 17, 55, 56, 17, 55, 56, 17, 55, 56, 00410 17, 55, 56, 17, 55, 56, 25, 55, 56, 24, 00411 54, 56, 18, 55, 56, 23, 54, 56, 22, 53, 00412 00413 55, 56, 21, 55, 56, 21, 55, 56, 21, 55, 00414 56, 21, 55, 56, 21, 55, 56, 21, 55, 56, 00415 21, 55, 56, 21, 55, 56, 21, 55, 56, 21, 00416 55, 56, 21, 55, 56, 21, 55, 56, 21, 55, 00417 56, 21, 55, 56, 21, 55, 56, 21, 55, 56, 00418 21, 55, 56, 21, 55, 56, 21, 55, 56, 21, 00419 55, 56, 21, 55, 56, 21, 55, 56, 55, 56, 00420 16410, 27, 54, 56, 8220, 55, 56, 8220, 53, 55, 00421 56, 8220, 55, 56, 8220, 55, 56, 8220, 55, 56, 00422 36, 37, 55, 56, 37, 52, 55, 56, 36, 37, 00423 00424 53, 55, 56, 35, 37, 51, 55, 56, 36, 37, 00425 55, 56, 36, 37, 55, 56, 37, 55, 56, 36, 00426 37, 55, 56, 42, 43, 55, 56, 41, 43, 52, 00427 55, 56, 42, 43, 53, 55, 56, 43, 51, 55, 00428 56, 42, 43, 55, 56, 42, 43, 55, 56, 43, 00429 55, 56, 42, 43, 55, 56, 46, 48, 55, 56, 00430 46, 47, 54, 56, 46, 48, 52, 55, 56, 46, 00431 48, 53, 55, 56, 46, 48, 51, 55, 56, 46, 00432 48, 55, 56, 46, 48, 55, 56, 48, 55, 56, 00433 46, 48, 55, 56, 53, 52, 51, 17, 30, 17, 00434 00435 30, 17, 30, 17, 30, 17, 30, 17, 30, 15, 00436 17, 30, 17, 30, 17, 30, 17, 30, 17, 30, 00437 17, 30, 17, 30, 17, 30, 17, 30, 17, 30, 00438 17, 30, 16, 17, 30, 17, 30, 16, 17, 30, 00439 17, 30, 17, 30, 17, 30, 17, 30, 17, 30, 00440 17, 30, 17, 30, 17, 30, 17, 30, 17, 30, 00441 10, 9, 9, 12, 11, 12, 12, 53, 12, 12, 00442 12, 52, 12, 51, 12, 5, 5, 6, 7, 7, 00443 17, 17, 17, 17, 17, 17, 15, 17, 17, 17, 00444 17, 17, 17, 17, 17, 17, 17, 17, 16, 17, 00445 00446 17, 16, 17, 17, 17, 17, 17, 17, 17, 17, 00447 17, 17, 17, 25, 24, 18, 22, 53, 21, 21, 00448 21, 21, 21, 19, 21, 21, 21, 21, 21, 21, 00449 21, 21, 21, 21, 21, 20, 21, 21, 20, 21, 00450 21, 21, 21, 21, 21, 21, 21, 21, 21,16410, 00451 27, 8218, 36, 36, 53, 52, 36, 33, 33, 32, 00452 42, 42, 53, 51, 42, 39, 39, 38, 46, 46, 00453 46, 53, 53, 46, 46, 50, 49, 17, 30, 17, 00454 30, 17, 30, 17, 30, 17, 30, 17, 30, 17, 00455 30, 15, 17, 30, 17, 30, 17, 30, 17, 30, 00456 00457 17, 30, 17, 30, 17, 30, 17, 30, 17, 30, 00458 17, 30, 17, 30, 17, 30, 17, 30, 17, 30, 00459 17, 30, 17, 30, 12, 50, 12, 49, 17, 17, 00460 17, 17, 17, 17, 17, 15, 17, 17, 17, 17, 00461 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 00462 17, 17, 21, 21, 21, 21, 21, 21, 19, 21, 00463 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 00464 21, 21, 21, 21, 34, 50, 40, 49, 44, 50, 00465 45, 49, 17, 30, 3, 17, 30, 15, 17, 30, 00466 17, 30, 17, 30, 17, 30, 17, 30, 1, 17, 00467 00468 30, 17, 30, 17, 30, 17, 30, 17, 30, 17, 00469 30, 17, 30, 17, 30, 17, 30, 17, 30, 17, 00470 30, 17, 3, 17, 15, 17, 17, 17, 17, 17, 00471 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 00472 17, 21, 21, 21, 21, 21, 21, 21, 21, 21, 00473 21, 21, 21, 21, 21, 21, 17, 30, 15, 17, 00474 30, 17, 30, 17, 30, 17, 30, 17, 30, 17, 00475 30, 17, 30, 17, 30, 17, 15, 17, 17, 17, 00476 17, 17, 17, 17, 17, 21, 21, 21, 21, 21, 00477 21, 21, 21, 2, 17, 30, 17, 30, 4, 17, 00478 00479 17, 21, 21, 17, 30, 4, 17, 21 00480 } ; 00481 00482 static yyconst flex_int16_t yy_accept[490] = 00483 { 0, 00484 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00485 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 00486 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 00487 3, 4, 6, 8, 11, 14, 17, 19, 21, 23, 00488 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, 00489 66, 70, 74, 78, 82, 86, 90, 94, 98, 102, 00490 106, 110, 114, 118, 122, 124, 127, 130, 133, 136, 00491 139, 142, 145, 149, 153, 157, 160, 164, 167, 170, 00492 173, 176, 179, 182, 185, 188, 191, 194, 197, 200, 00493 203, 206, 209, 212, 215, 218, 221, 224, 227, 230, 00494 00495 233, 236, 239, 242, 245, 248, 251, 254, 257, 260, 00496 263, 266, 269, 272, 275, 278, 281, 284, 287, 290, 00497 293, 296, 299, 303, 306, 309, 312, 315, 318, 321, 00498 324, 327, 330, 333, 336, 339, 342, 345, 348, 351, 00499 354, 357, 360, 363, 366, 369, 372, 375, 378, 382, 00500 385, 388, 391, 395, 399, 404, 409, 413, 417, 420, 00501 424, 428, 433, 438, 442, 446, 450, 453, 457, 461, 00502 465, 470, 475, 480, 484, 488, 491, 495, 495, 496, 00503 496, 497, 498, 498, 500, 502, 504, 506, 508, 510, 00504 513, 515, 517, 519, 521, 523, 525, 527, 529, 531, 00505 00506 533, 536, 538, 541, 543, 545, 547, 549, 551, 553, 00507 555, 557, 559, 561, 561, 562, 563, 564, 565, 566, 00508 567, 569, 570, 571, 573, 575, 576, 577, 578, 579, 00509 580, 581, 582, 583, 584, 585, 586, 587, 589, 590, 00510 591, 592, 593, 594, 595, 596, 597, 598, 599, 601, 00511 602, 604, 605, 606, 607, 608, 609, 610, 611, 612, 00512 613, 614, 615, 616, 617, 619, 620, 621, 622, 623, 00513 624, 626, 627, 628, 629, 630, 631, 632, 633, 634, 00514 635, 636, 638, 639, 641, 642, 643, 644, 645, 646, 00515 647, 648, 649, 650, 651, 652, 653, 654, 654, 656, 00516 00517 657, 658, 659, 660, 661, 662, 664, 664, 665, 666, 00518 667, 668, 669, 670, 670, 671, 673, 674, 675, 676, 00519 677, 678, 680, 682, 684, 686, 688, 690, 692, 695, 00520 697, 699, 701, 703, 705, 707, 709, 711, 713, 715, 00521 717, 719, 721, 723, 725, 727, 729, 730, 731, 732, 00522 733, 734, 735, 736, 738, 739, 740, 741, 742, 743, 00523 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 00524 754, 755, 756, 757, 758, 759, 761, 762, 763, 764, 00525 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 00526 775, 777, 777, 779, 779, 781, 783, 785, 788, 791, 00527 00528 793, 795, 797, 799, 800, 802, 804, 806, 808, 810, 00529 812, 814, 816, 818, 820, 822, 823, 825, 827, 828, 00530 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 00531 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 00532 849, 850, 851, 852, 853, 854, 855, 856, 857, 859, 00533 862, 864, 866, 868, 870, 872, 874, 876, 876, 877, 00534 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 00535 889, 890, 891, 892, 893, 894, 895, 897, 899, 900, 00536 901, 902, 903, 904, 906, 907, 908, 909, 909 00537 } ; 00538 00539 static yyconst flex_int32_t yy_ec[256] = 00540 { 0, 00541 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 00542 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00543 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00544 1, 2, 4, 5, 6, 1, 4, 4, 7, 8, 00545 9, 4, 4, 10, 4, 11, 4, 12, 12, 12, 00546 12, 12, 12, 12, 12, 12, 12, 13, 4, 4, 00547 4, 4, 1, 1, 14, 14, 14, 14, 14, 15, 00548 14, 14, 14, 14, 14, 14, 14, 16, 14, 14, 00549 14, 17, 14, 18, 19, 14, 14, 14, 14, 14, 00550 4, 20, 4, 1, 21, 4, 22, 23, 24, 25, 00551 00552 26, 27, 28, 29, 30, 14, 31, 32, 33, 34, 00553 35, 36, 14, 37, 38, 39, 40, 14, 41, 42, 00554 43, 14, 4, 4, 4, 4, 1, 1, 1, 1, 00555 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00556 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00557 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00558 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00559 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00560 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00561 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00562 00563 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00564 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00565 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00566 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00567 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00568 1, 1, 1, 1, 1 00569 } ; 00570 00571 static yyconst flex_int32_t yy_meta[44] = 00572 { 0, 00573 1, 2, 3, 4, 5, 4, 5, 2, 2, 4, 00574 4, 6, 2, 7, 7, 7, 7, 7, 7, 8, 00575 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 00576 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 00577 7, 7, 7 00578 } ; 00579 00580 static yyconst flex_int16_t yy_base[516] = 00581 { 0, 00582 0, 38, 78, 0, 121, 0, 164, 0, 207, 0, 00583 250, 0, 293, 0, 335, 0, 375, 0, 418, 458, 00584 6, 8, 10, 12, 496, 534, 572, 610, 648, 686, 00585 1132, 1133, 1133, 1126, 0, 1123, 11, 15, 16, 1133, 00586 0, 1107, 1093, 19, 1090, 22, 0, 1089, 14, 1099, 00587 16, 26, 1092, 33, 1101, 1087, 1084, 13, 338, 1094, 00588 1082, 425, 1089, 1087, 23, 1133, 0, 23, 429, 433, 00589 0, 1114, 1110, 60, 1107, 1133, 0, 1133, 726, 746, 00590 37, 322, 0, 65, 434, 467, 1111, 1133, 1133, 0, 00591 339, 471, 474, 1133, 0, 1090, 1076, 342, 1073, 475, 00592 00593 13, 1072, 316, 1082, 321, 320, 1075, 335, 1084, 1070, 00594 1067, 334, 421, 1077, 1065, 480, 1072, 1070, 62, 1133, 00595 1097, 1133, 0, 0, 1076, 360, 1060, 489, 332, 1059, 00596 326, 1069, 412, 392, 1062, 487, 1071, 1057, 1054, 411, 00597 502, 1053, 525, 1060, 1058, 74, 1133, 1133, 0, 462, 00598 539, 543, 0, 1082, 538, 1079, 522, 550, 450, 556, 00599 0, 1080, 561, 1077, 542, 565, 454, 581, 1063, 1062, 00600 1076, 594, 1073, 599, 603, 600, 619, 1074, 0, 1071, 00601 1072, 1069, 578, 0, 1043, 1040, 1033, 589, 1047, 1033, 00602 1044, 1047, 1034, 1040, 480, 1042, 1031, 1027, 1028, 1027, 00603 00604 0, 1025, 0, 1027, 1020, 1020, 1027, 1026, 1016, 1022, 00605 1010, 1022, 1025, 34, 1133, 0, 626, 0, 1048, 1044, 00606 633, 1041, 627, 1042, 1039, 0, 0, 638, 1043, 0, 00607 652, 0, 1012, 1009, 1002, 653, 1016, 1002, 1013, 1016, 00608 1003, 1009, 493, 1011, 1000, 996, 997, 996, 0, 994, 00609 0, 996, 989, 989, 996, 995, 985, 991, 979, 991, 00610 994, 487, 1133, 1017, 0, 0, 986, 977, 656, 991, 00611 977, 988, 991, 978, 984, 614, 986, 975, 971, 972, 00612 971, 0, 969, 0, 971, 964, 964, 971, 970, 960, 00613 955, 967, 970, 532, 1133, 1133, 0, 990, 657, 989, 00614 00615 664, 1133, 562, 1133, 0, 667, 986, 985, 668, 1133, 00616 619, 1133, 971, 673, 985, 676, 986, 981, 677, 1133, 00617 1133, 949, 960, 959, 958, 961, 944, 942, 978, 952, 00618 952, 951, 954, 942, 951, 938, 949, 933, 936, 931, 00619 928, 940, 934, 933, 0, 0, 926, 937, 936, 935, 00620 938, 921, 919, 955, 929, 929, 928, 931, 919, 928, 00621 915, 926, 910, 913, 908, 905, 917, 911, 910, 903, 00622 914, 913, 916, 899, 897, 0, 908, 908, 907, 910, 00623 898, 907, 881, 875, 855, 857, 837, 830, 836, 830, 00624 1133, 635, 1133, 646, 1133, 1133, 825, 0, 0, 800, 00625 00626 805, 791, 791, 818, 773, 733, 742, 726, 737, 722, 00627 734, 722, 747, 729, 729, 723, 0, 0, 711, 714, 00628 706, 713, 706, 709, 718, 702, 713, 696, 708, 692, 00629 717, 699, 699, 696, 684, 689, 681, 688, 681, 684, 00630 693, 677, 688, 673, 685, 673, 683, 683, 668, 702, 00631 668, 662, 668, 667, 659, 673, 660, 0, 651, 684, 00632 636, 627, 596, 593, 572, 578, 561, 551, 550, 530, 00633 527, 520, 499, 500, 485, 503, 460, 450, 0, 446, 00634 440, 433, 425, 423, 0, 419, 405, 1133, 766, 774, 00635 782, 790, 798, 806, 809, 811, 818, 826, 834, 837, 00636 00637 839, 841, 848, 851, 857, 865, 872, 880, 888, 895, 00638 903, 911, 919, 367, 922 00639 } ; 00640 00641 static yyconst flex_int16_t yy_def[516] = 00642 { 0, 00643 489, 489, 488, 3, 488, 5, 488, 7, 488, 9, 00644 488, 11, 488, 13, 489, 15, 488, 17, 490, 490, 00645 15, 15, 15, 15, 491, 491, 492, 492, 493, 493, 00646 488, 488, 488, 488, 494, 488, 488, 488, 488, 488, 00647 495, 495, 495, 495, 495, 495, 495, 495, 495, 495, 00648 495, 495, 495, 495, 495, 495, 495, 495, 495, 495, 00649 495, 495, 495, 495, 488, 488, 496, 496, 496, 496, 00650 497, 488, 497, 498, 497, 488, 497, 488, 499, 499, 00651 80, 80, 500, 500, 500, 500, 488, 488, 488, 501, 00652 501, 501, 501, 488, 502, 502, 502, 502, 502, 502, 00653 00654 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 00655 502, 502, 502, 502, 502, 502, 502, 502, 488, 488, 00656 488, 488, 503, 504, 504, 504, 504, 504, 504, 504, 00657 504, 504, 504, 504, 504, 504, 504, 504, 504, 504, 00658 504, 504, 504, 504, 504, 505, 488, 488, 494, 488, 00659 488, 488, 506, 488, 507, 488, 506, 506, 508, 506, 00660 509, 488, 510, 488, 509, 509, 511, 509, 512, 512, 00661 488, 513, 488, 512, 512, 512, 512, 488, 494, 488, 00662 488, 488, 488, 495, 495, 495, 495, 495, 495, 495, 00663 495, 495, 495, 495, 495, 495, 495, 495, 495, 495, 00664 00665 495, 495, 495, 495, 495, 495, 495, 495, 495, 495, 00666 495, 495, 495, 488, 488, 496, 496, 497, 488, 497, 00667 498, 497, 80, 497, 497, 80, 500, 500, 488, 501, 00668 501, 502, 502, 502, 502, 502, 502, 502, 502, 502, 00669 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 00670 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 00671 502, 488, 488, 488, 503, 504, 504, 504, 504, 504, 00672 504, 504, 504, 504, 504, 504, 504, 504, 504, 504, 00673 504, 504, 504, 504, 504, 504, 504, 504, 504, 504, 00674 504, 504, 504, 505, 488, 488, 506, 488, 507, 488, 00675 00676 506, 488, 488, 488, 509, 510, 488, 488, 509, 488, 00677 488, 488, 512, 512, 488, 513, 513, 488, 512, 488, 00678 488, 495, 495, 495, 495, 495, 495, 495, 495, 495, 00679 495, 495, 495, 495, 495, 495, 495, 495, 495, 495, 00680 495, 495, 495, 495, 497, 497, 502, 502, 502, 502, 00681 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 00682 502, 502, 502, 502, 502, 502, 502, 502, 502, 504, 00683 504, 504, 504, 504, 504, 504, 504, 504, 504, 504, 00684 504, 504, 504, 504, 504, 504, 504, 504, 504, 504, 00685 488, 488, 488, 488, 488, 488, 495, 495, 495, 495, 00686 00687 495, 495, 495, 488, 495, 495, 495, 495, 495, 495, 00688 495, 495, 495, 495, 495, 502, 502, 502, 502, 502, 00689 502, 502, 502, 502, 502, 502, 502, 502, 502, 502, 00690 502, 502, 502, 504, 504, 504, 504, 504, 504, 504, 00691 504, 504, 504, 504, 504, 504, 504, 504, 495, 495, 00692 495, 495, 495, 495, 495, 495, 495, 514, 502, 502, 00693 502, 502, 502, 502, 502, 502, 502, 504, 504, 504, 00694 504, 504, 504, 504, 504, 488, 495, 495, 515, 502, 00695 502, 504, 504, 495, 515, 502, 504, 0, 488, 488, 00696 488, 488, 488, 488, 488, 488, 488, 488, 488, 488, 00697 00698 488, 488, 488, 488, 488, 488, 488, 488, 488, 488, 00699 488, 488, 488, 488, 488 00700 } ; 00701 00702 static yyconst flex_int16_t yy_nxt[1177] = 00703 { 0, 00704 488, 488, 33, 488, 34, 35, 36, 32, 33, 32, 00705 33, 32, 33, 32, 33, 181, 37, 182, 38, 181, 00706 181, 182, 182, 181, 214, 182, 181, 181, 182, 182, 00707 215, 183, 183, 189, 206, 214, 37, 190, 188, 39, 00708 33, 215, 34, 35, 36, 192, 237, 195, 193, 207, 00709 238, 183, 183, 226, 37, 197, 38, 196, 188, 201, 00710 198, 179, 199, 262, 263, 202, 203, 179, 179, 181, 00711 203, 182, 179, 226, 37, 294, 295, 39, 32, 32, 00712 40, 32, 34, 35, 36, 32, 32, 32, 32, 32, 00713 32, 41, 42, 43, 44, 45, 46, 32, 41, 47, 00714 00715 48, 49, 50, 51, 52, 53, 41, 54, 41, 55, 00716 41, 56, 57, 58, 59, 60, 61, 62, 63, 41, 00717 64, 32, 65, 33, 32, 34, 35, 36, 66, 32, 00718 32, 32, 32, 32, 67, 67, 67, 68, 67, 69, 00719 32, 67, 67, 67, 67, 67, 67, 67, 67, 67, 00720 67, 67, 67, 67, 67, 67, 67, 68, 67, 67, 00721 70, 67, 67, 67, 71, 72, 33, 71, 73, 74, 00722 75, 32, 76, 77, 71, 71, 78, 79, 79, 79, 00723 80, 79, 81, 71, 79, 79, 79, 79, 79, 79, 00724 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 00725 00726 80, 79, 79, 82, 79, 79, 79, 32, 32, 33, 00727 32, 34, 35, 36, 32, 32, 32, 32, 32, 32, 00728 83, 83, 83, 84, 83, 85, 32, 83, 83, 83, 00729 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 00730 83, 83, 83, 84, 83, 83, 86, 83, 83, 83, 00731 32, 87, 33, 32, 34, 35, 36, 88, 88, 88, 00732 32, 32, 89, 90, 90, 90, 91, 90, 92, 32, 00733 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 00734 90, 90, 90, 90, 90, 90, 91, 90, 90, 93, 00735 90, 90, 90, 32, 32, 94, 32, 34, 35, 36, 00736 00737 32, 32, 32, 32, 32, 32, 95, 96, 97, 98, 00738 99, 100, 32, 95, 101, 102, 103, 104, 105, 106, 00739 107, 95, 108, 95, 109, 95, 110, 111, 112, 113, 00740 114, 115, 116, 117, 95, 118, 119, 120, 226, 34, 00741 35, 36, 181, 181, 182, 182, 181, 240, 182, 245, 00742 241, 37, 243, 38, 246, 254, 247, 273, 226, 208, 00743 274, 249, 244, 209, 181, 270, 182, 250, 251, 271, 00744 255, 37, 251, 479, 39, 32, 121, 122, 32, 34, 00745 123, 36, 32, 32, 32, 32, 32, 32, 124, 125, 00746 124, 126, 127, 128, 32, 124, 129, 130, 131, 132, 00747 00748 133, 134, 135, 124, 136, 124, 137, 124, 138, 139, 00749 140, 141, 124, 142, 143, 144, 124, 145, 32, 146, 00750 147, 278, 34, 149, 36, 181, 279, 182, 280, 181, 00751 284, 182, 287, 181, 150, 182, 151, 181, 181, 182, 00752 182, 188, 256, 276, 251, 217, 257, 288, 203, 217, 00753 228, 303, 304, 277, 150, 311, 312, 152, 32, 146, 00754 147, 188, 34, 149, 36, 217, 181, 284, 182, 217, 00755 228, 181, 487, 182, 150, 181, 151, 182, 181, 181, 00756 182, 182, 251, 228, 181, 486, 182, 231, 262, 263, 00757 231, 236, 203, 181, 150, 182, 236, 152, 33, 484, 00758 00759 154, 155, 156, 228, 476, 269, 181, 231, 182, 330, 00760 231, 236, 157, 282, 158, 159, 236, 331, 284, 283, 00761 284, 376, 355, 289, 284, 269, 300, 290, 182, 181, 00762 356, 182, 157, 294, 295, 160, 33, 376, 154, 155, 00763 156, 269, 179, 181, 179, 182, 181, 181, 308, 182, 00764 157, 376, 158, 159, 300, 183, 182, 179, 483, 183, 00765 300, 269, 182, 392, 304, 179, 301, 179, 284, 181, 00766 157, 308, 301, 160, 33, 183, 162, 163, 164, 183, 00767 179, 309, 181, 482, 182, 181, 301, 308, 165, 376, 00768 166, 167, 301, 181, 251, 182, 313, 309, 179, 418, 00769 00770 179, 309, 488, 181, 313, 182, 313, 181, 165, 182, 00771 418, 168, 33, 317, 162, 163, 164, 309, 314, 319, 00772 394, 312, 314, 181, 418, 182, 165, 481, 166, 167, 00773 181, 218, 182, 218, 179, 319, 392, 304, 314, 319, 00774 179, 179, 181, 377, 182, 179, 165, 394, 312, 168, 00775 170, 378, 171, 172, 173, 319, 181, 181, 182, 182, 00776 181, 179, 182, 179, 174, 251, 175, 176, 300, 480, 00777 182, 179, 181, 179, 308, 488, 179, 313, 313, 313, 00778 179, 181, 179, 182, 174, 476, 179, 177, 170, 418, 00779 171, 172, 173, 203, 399, 317, 314, 399, 399, 478, 00780 00781 203, 477, 174, 476, 175, 176, 399, 284, 284, 475, 00782 284, 284, 474, 473, 472, 471, 470, 469, 376, 284, 00783 468, 376, 174, 251, 251, 177, 218, 458, 467, 218, 00784 218, 218, 218, 251, 251, 218, 218, 466, 465, 464, 00785 463, 462, 461, 460, 251, 218, 218, 459, 418, 218, 00786 224, 218, 225, 203, 203, 218, 218, 458, 457, 203, 00787 203, 456, 455, 454, 453, 218, 32, 32, 32, 32, 00788 32, 32, 32, 32, 148, 148, 148, 148, 148, 148, 00789 148, 148, 153, 153, 153, 153, 153, 153, 153, 153, 00790 161, 161, 161, 161, 161, 161, 161, 161, 169, 169, 00791 00792 169, 169, 169, 169, 169, 169, 179, 179, 452, 179, 00793 179, 179, 179, 179, 184, 184, 216, 216, 218, 404, 00794 451, 218, 218, 218, 218, 218, 221, 221, 450, 221, 00795 221, 221, 221, 221, 223, 203, 449, 223, 223, 223, 00796 223, 223, 227, 227, 230, 230, 232, 232, 265, 265, 00797 399, 265, 265, 265, 265, 265, 266, 266, 296, 296, 00798 296, 448, 296, 296, 296, 297, 297, 447, 297, 446, 00799 297, 297, 299, 299, 445, 299, 299, 299, 299, 299, 00800 302, 302, 302, 302, 302, 302, 302, 302, 305, 305, 00801 444, 305, 284, 305, 305, 306, 306, 443, 306, 306, 00802 00803 306, 306, 306, 310, 310, 310, 310, 310, 310, 310, 00804 310, 313, 313, 313, 313, 442, 313, 313, 313, 316, 00805 316, 316, 316, 316, 316, 316, 316, 485, 485, 441, 00806 376, 440, 439, 284, 284, 438, 437, 436, 435, 376, 00807 434, 433, 432, 431, 430, 429, 428, 251, 427, 426, 00808 425, 418, 424, 423, 251, 251, 404, 422, 421, 420, 00809 419, 418, 417, 416, 415, 414, 413, 412, 411, 410, 00810 203, 409, 408, 407, 399, 406, 405, 203, 203, 404, 00811 403, 402, 401, 400, 399, 398, 397, 396, 488, 395, 00812 314, 307, 393, 298, 391, 390, 389, 284, 388, 387, 00813 00814 386, 385, 284, 384, 383, 382, 381, 284, 380, 379, 00815 376, 375, 374, 373, 372, 284, 371, 370, 264, 369, 00816 368, 251, 367, 366, 365, 364, 363, 251, 362, 361, 00817 360, 359, 251, 358, 357, 354, 353, 352, 351, 350, 00818 251, 349, 348, 347, 229, 222, 220, 346, 345, 219, 00819 344, 343, 203, 342, 341, 340, 339, 338, 203, 337, 00820 336, 335, 334, 203, 333, 332, 329, 328, 327, 326, 00821 325, 203, 324, 323, 322, 180, 178, 321, 320, 318, 00822 315, 314, 314, 307, 178, 180, 298, 293, 292, 291, 00823 284, 286, 285, 281, 275, 272, 268, 267, 264, 261, 00824 00825 260, 259, 258, 251, 253, 252, 248, 242, 239, 235, 00826 234, 233, 229, 222, 220, 219, 213, 212, 211, 210, 00827 203, 205, 204, 200, 194, 191, 187, 186, 185, 180, 00828 178, 488, 31, 488, 488, 488, 488, 488, 488, 488, 00829 488, 488, 488, 488, 488, 488, 488, 488, 488, 488, 00830 488, 488, 488, 488, 488, 488, 488, 488, 488, 488, 00831 488, 488, 488, 488, 488, 488, 488, 488, 488, 488, 00832 488, 488, 488, 488, 488, 488 00833 } ; 00834 00835 static yyconst flex_int16_t yy_chk[1177] = 00836 { 0, 00837 0, 0, 1, 0, 1, 1, 1, 21, 21, 22, 00838 22, 23, 23, 24, 24, 37, 1, 37, 1, 38, 00839 39, 38, 39, 44, 65, 44, 46, 68, 46, 68, 00840 65, 38, 39, 47, 58, 214, 1, 47, 46, 1, 00841 2, 214, 2, 2, 2, 49, 101, 51, 49, 58, 00842 101, 38, 39, 81, 2, 52, 2, 51, 46, 54, 00843 52, 74, 52, 119, 119, 54, 54, 74, 74, 84, 00844 54, 84, 74, 81, 2, 146, 146, 2, 3, 3, 00845 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 00846 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 00847 00848 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 00849 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 00850 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 00851 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 00852 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 00853 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 00854 5, 5, 5, 5, 7, 7, 7, 7, 7, 7, 00855 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 00856 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 00857 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 00858 00859 7, 7, 7, 7, 7, 7, 7, 9, 9, 9, 00860 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 00861 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 00862 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 00863 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 00864 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 00865 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 00866 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 00867 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 00868 11, 11, 11, 13, 13, 13, 13, 13, 13, 13, 00869 00870 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 00871 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 00872 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 00873 13, 13, 13, 13, 13, 13, 15, 15, 82, 15, 00874 15, 15, 59, 91, 59, 91, 98, 103, 98, 106, 00875 103, 15, 105, 15, 106, 112, 106, 131, 82, 59, 00876 131, 108, 105, 59, 126, 129, 126, 108, 108, 129, 00877 112, 15, 108, 514, 15, 17, 17, 17, 17, 17, 00878 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 00879 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 00880 00881 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 00882 17, 17, 17, 17, 17, 17, 17, 17, 19, 19, 00883 19, 134, 19, 19, 19, 113, 134, 113, 134, 62, 00884 487, 62, 140, 69, 19, 69, 19, 70, 85, 70, 00885 85, 62, 113, 133, 486, 69, 113, 140, 484, 70, 00886 85, 159, 159, 133, 19, 167, 167, 19, 20, 20, 00887 20, 62, 20, 20, 20, 69, 150, 483, 150, 70, 00888 85, 86, 482, 86, 20, 92, 20, 92, 93, 100, 00889 93, 100, 481, 86, 116, 480, 116, 92, 262, 262, 00890 93, 100, 478, 128, 20, 128, 116, 20, 25, 477, 00891 00892 25, 25, 25, 86, 476, 128, 141, 92, 141, 195, 00893 93, 100, 25, 136, 25, 25, 116, 195, 475, 136, 00894 136, 474, 243, 141, 136, 128, 157, 141, 157, 143, 00895 243, 143, 25, 294, 294, 25, 26, 473, 26, 26, 00896 26, 143, 155, 151, 155, 151, 165, 152, 165, 152, 00897 26, 472, 26, 26, 158, 151, 158, 155, 471, 152, 00898 160, 143, 160, 303, 303, 163, 158, 163, 470, 166, 00899 26, 166, 160, 26, 27, 151, 27, 27, 27, 152, 00900 163, 166, 183, 469, 183, 168, 158, 168, 27, 468, 00901 27, 27, 160, 188, 467, 188, 172, 168, 172, 466, 00902 00903 172, 166, 176, 174, 176, 174, 176, 175, 27, 175, 00904 465, 27, 28, 172, 28, 28, 28, 168, 174, 175, 00905 311, 311, 175, 177, 464, 177, 28, 463, 28, 28, 00906 217, 223, 217, 223, 221, 177, 392, 392, 177, 175, 00907 221, 221, 228, 276, 228, 221, 28, 394, 394, 28, 00908 29, 276, 29, 29, 29, 177, 231, 236, 231, 236, 00909 269, 299, 269, 299, 29, 462, 29, 29, 301, 461, 00910 301, 306, 309, 306, 309, 314, 299, 314, 316, 314, 00911 316, 319, 316, 319, 29, 460, 306, 29, 30, 459, 00912 30, 30, 30, 457, 456, 316, 319, 455, 454, 453, 00913 00914 452, 451, 30, 450, 30, 30, 449, 448, 447, 446, 00915 445, 444, 443, 442, 441, 440, 439, 438, 437, 436, 00916 435, 434, 30, 433, 432, 30, 79, 431, 430, 79, 00917 79, 79, 79, 429, 428, 79, 79, 427, 426, 425, 00918 424, 423, 422, 421, 420, 79, 80, 419, 416, 80, 00919 80, 80, 80, 415, 414, 80, 80, 413, 412, 411, 00920 410, 409, 408, 407, 406, 80, 489, 489, 489, 489, 00921 489, 489, 489, 489, 490, 490, 490, 490, 490, 490, 00922 490, 490, 491, 491, 491, 491, 491, 491, 491, 491, 00923 492, 492, 492, 492, 492, 492, 492, 492, 493, 493, 00924 00925 493, 493, 493, 493, 493, 493, 494, 494, 405, 494, 00926 494, 494, 494, 494, 495, 495, 496, 496, 497, 404, 00927 403, 497, 497, 497, 497, 497, 498, 498, 402, 498, 00928 498, 498, 498, 498, 499, 401, 400, 499, 499, 499, 00929 499, 499, 500, 500, 501, 501, 502, 502, 503, 503, 00930 397, 503, 503, 503, 503, 503, 504, 504, 505, 505, 00931 505, 390, 505, 505, 505, 506, 506, 389, 506, 388, 00932 506, 506, 507, 507, 387, 507, 507, 507, 507, 507, 00933 508, 508, 508, 508, 508, 508, 508, 508, 509, 509, 00934 386, 509, 385, 509, 509, 510, 510, 384, 510, 510, 00935 00936 510, 510, 510, 511, 511, 511, 511, 511, 511, 511, 00937 511, 512, 512, 512, 512, 383, 512, 512, 512, 513, 00938 513, 513, 513, 513, 513, 513, 513, 515, 515, 382, 00939 381, 380, 379, 378, 377, 375, 374, 373, 372, 371, 00940 370, 369, 368, 367, 366, 365, 364, 363, 362, 361, 00941 360, 359, 358, 357, 356, 355, 354, 353, 352, 351, 00942 350, 349, 348, 347, 344, 343, 342, 341, 340, 339, 00943 338, 337, 336, 335, 334, 333, 332, 331, 330, 329, 00944 328, 327, 326, 325, 324, 323, 322, 318, 317, 315, 00945 313, 308, 307, 300, 298, 293, 292, 291, 290, 289, 00946 00947 288, 287, 286, 285, 283, 281, 280, 279, 278, 277, 00948 275, 274, 273, 272, 271, 270, 268, 267, 264, 261, 00949 260, 259, 258, 257, 256, 255, 254, 253, 252, 250, 00950 248, 247, 246, 245, 244, 242, 241, 240, 239, 238, 00951 237, 235, 234, 233, 229, 225, 224, 222, 220, 219, 00952 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, 00953 202, 200, 199, 198, 197, 196, 194, 193, 192, 191, 00954 190, 189, 187, 186, 185, 182, 181, 180, 178, 173, 00955 171, 170, 169, 164, 162, 156, 154, 145, 144, 142, 00956 139, 138, 137, 135, 132, 130, 127, 125, 121, 118, 00957 00958 117, 115, 114, 111, 110, 109, 107, 104, 102, 99, 00959 97, 96, 87, 75, 73, 72, 64, 63, 61, 60, 00960 57, 56, 55, 53, 50, 48, 45, 43, 42, 36, 00961 34, 31, 488, 488, 488, 488, 488, 488, 488, 488, 00962 488, 488, 488, 488, 488, 488, 488, 488, 488, 488, 00963 488, 488, 488, 488, 488, 488, 488, 488, 488, 488, 00964 488, 488, 488, 488, 488, 488, 488, 488, 488, 488, 00965 488, 488, 488, 488, 488, 488 00966 } ; 00967 00968 extern int pycodeYY_flex_debug; 00969 int pycodeYY_flex_debug = 0; 00970 00971 static yy_state_type *yy_state_buf=0, *yy_state_ptr=0; 00972 static char *yy_full_match; 00973 static int yy_lp; 00974 static int yy_looking_for_trail_begin = 0; 00975 static int yy_full_lp; 00976 static int *yy_full_state; 00977 #define YY_TRAILING_MASK 0x2000 00978 #define YY_TRAILING_HEAD_MASK 0x4000 00979 #define REJECT \ 00980 { \ 00981 *yy_cp = (yy_hold_char); /* undo effects of setting up pycodeYYtext */ \ 00982 yy_cp = (yy_full_match); /* restore poss. backed-over text */ \ 00983 (yy_lp) = yy_full_lp; /* restore orig. accepting pos. */ \ 00984 (yy_state_ptr) = yy_full_state; /* restore orig. state */ \ 00985 yy_current_state = *(yy_state_ptr); /* restore curr. state */ \ 00986 ++(yy_lp); \ 00987 goto find_rule; \ 00988 } 00989 00990 #define yymore() yymore_used_but_not_detected 00991 #define YY_MORE_ADJ 0 00992 #define YY_RESTORE_YY_MORE_OFFSET 00993 char *pycodeYYtext; 00994 #line 1 "pycode.l" 00995 /****************************************************************************** 00996 * 00997 * $Id: pycode.h,v 1.9 2001/03/19 19:27:39 root Exp $ 00998 * 00999 * Copyright (C) 1997-2008 by Dimitri van Heesch. 01000 * 01001 * Permission to use, copy, modify, and distribute this software and its 01002 * documentation under the terms of the GNU General Public License is hereby 01003 * granted. No representations are made about the suitability of this software 01004 * for any purpose. It is provided "as is" without express or implied warranty. 01005 * See the GNU General Public License for more details. 01006 * 01007 * Documents produced by Doxygen are derivative works derived from the 01008 * input used in their production; they are not affected by this license. 01009 * 01010 */ 01011 /* This code is based on the work done by the MoxyPyDoxy team 01012 * (Linda Leong, Mike Rivera, Kim Truong, and Gabriel Estrada) 01013 * in Spring 2005 as part of CS 179E: Compiler Design Project 01014 * at the University of California, Riverside; the course was 01015 * taught by Peter H. Froehlich <phf@acm.org>. 01016 */ 01017 #line 26 "pycode.l" 01018 01019 #include <stdio.h> 01020 #include <qvaluestack.h> 01021 01022 #include "pycode.h" 01023 #include "message.h" 01024 01025 #include "scanner.h" 01026 #include "entry.h" 01027 #include "doxygen.h" 01028 #include "outputlist.h" 01029 #include "util.h" 01030 #include "membername.h" 01031 #include "searchindex.h" 01032 01033 #define YY_NEVER_INTERACTIVE 1 01034 01035 static ClassSDict g_codeClassSDict(17); 01036 static QCString g_curClassName; 01037 static QStrList g_curClassBases; 01038 01039 01040 static CodeOutputInterface * g_code; 01041 static const char * g_inputString; 01042 static int g_inputPosition; 01043 static const char * g_currentFontClass; 01044 static bool g_needsTermination; 01045 static int g_inputLines; 01046 static int g_yyLineNr; 01047 static FileDef * g_sourceFileDef; 01048 static Definition * g_currentDefinition; 01049 static MemberDef * g_currentMemberDef; 01050 static bool g_includeCodeFragment; 01051 static QCString g_realScope; 01052 static bool g_insideBody; 01053 static int g_bodyCurlyCount; 01054 static bool g_searchingForBody; 01055 static QCString g_classScope; 01056 static int g_paramParens; 01057 //static int g_anchorCount; 01058 01059 static bool g_exampleBlock; 01060 static QCString g_exampleName; 01061 static QCString g_exampleFile; 01062 01063 static QCString g_type; 01064 static QCString g_name; 01065 01066 static bool g_doubleStringIsDoc; 01067 static bool g_doubleQuote; 01068 static bool g_noSuiteFound; 01069 static int g_stringContext; 01070 01071 static QValueStack<uint> g_indents; 01072 01073 static void endFontClass(); 01074 static void adjustScopesAndSuites(unsigned indentLength); 01075 01076 01082 class PyVariableContext 01083 { 01084 public: 01085 static const ClassDef *dummyContext; 01086 class Scope : public SDict<ClassDef> 01087 { 01088 public: 01089 Scope() : SDict<ClassDef>(17) {} 01090 }; 01091 01092 PyVariableContext() 01093 { 01094 m_scopes.setAutoDelete(TRUE); 01095 } 01096 01097 virtual ~PyVariableContext() 01098 { 01099 } 01100 01101 void pushScope() 01102 { 01103 m_scopes.append(new Scope); 01104 } 01105 01106 void popScope() 01107 { 01108 if (m_scopes.count()>0) 01109 { 01110 m_scopes.remove(m_scopes.count()-1); 01111 } 01112 } 01113 01114 void clear() 01115 { 01116 m_scopes.clear(); 01117 m_globalScope.clear(); 01118 } 01119 01120 void clearExceptGlobal() 01121 { 01122 m_scopes.clear(); 01123 } 01124 01125 void addVariable(const QCString &type,const QCString &name); 01126 ClassDef *findVariable(const QCString &name); 01127 01128 private: 01129 Scope m_globalScope; 01130 QList<Scope> m_scopes; 01131 }; 01132 01133 void PyVariableContext::addVariable(const QCString &type,const QCString &name) 01134 { 01135 //printf("PyVariableContext::addVariable(%s,%s)\n",type.data(),name.data()); 01136 QCString ltype = type.simplifyWhiteSpace(); 01137 QCString lname = name.simplifyWhiteSpace(); 01138 01139 Scope *scope = m_scopes.count()==0 ? &m_globalScope : m_scopes.getLast(); 01140 ClassDef *varType; 01141 if ( 01142 (varType=g_codeClassSDict[ltype]) || // look for class definitions inside the code block 01143 (varType=getResolvedClass(g_currentDefinition,g_sourceFileDef,ltype)) // look for global class definitions 01144 ) 01145 { 01146 scope->append(lname,varType); // add it to a list 01147 } 01148 else 01149 { 01150 if (m_scopes.count()>0) // for local variables add a dummy entry so the name 01151 // is hidden to avoid FALSE links to global variables with the same name 01152 // TODO: make this work for namespaces as well! 01153 { 01154 scope->append(lname,dummyContext); 01155 } 01156 } 01157 } 01158 01159 ClassDef *PyVariableContext::findVariable(const QCString &name) 01160 { 01161 if (name.isEmpty()) return 0; 01162 ClassDef *result = 0; 01163 QListIterator<Scope> sli(m_scopes); 01164 Scope *scope; 01165 // search from inner to outer scope 01166 for (sli.toLast();(scope=sli.current());--sli) 01167 { 01168 result = scope->find(name); 01169 if (result) 01170 { 01171 return result; 01172 } 01173 } 01174 // nothing found -> also try the global scope 01175 result=m_globalScope.find(name); 01176 return result; 01177 } 01178 01179 static PyVariableContext g_theVarContext; 01180 const ClassDef *PyVariableContext::dummyContext = (ClassDef*)0x8; 01181 01182 class PyCallContext 01183 { 01184 public: 01185 struct Ctx 01186 { 01187 Ctx() : name(g_name), type(g_type), cd(0) {} 01188 QCString name; 01189 QCString type; 01190 ClassDef *cd; 01191 }; 01192 01193 PyCallContext() 01194 { 01195 m_classList.append(new Ctx); 01196 m_classList.setAutoDelete(TRUE); 01197 } 01198 01199 virtual ~PyCallContext() {} 01200 01201 void setClass(ClassDef *cd) 01202 { 01203 Ctx *ctx = m_classList.getLast(); 01204 if (ctx) 01205 { 01206 ctx->cd=cd; 01207 } 01208 } 01209 void pushScope() 01210 { 01211 m_classList.append(new Ctx); 01212 } 01213 01214 void popScope() 01215 { 01216 if (m_classList.count()>1) 01217 { 01218 Ctx *ctx = m_classList.getLast(); 01219 if (ctx) 01220 { 01221 g_name = ctx->name; 01222 g_type = ctx->type; 01223 } 01224 m_classList.removeLast(); 01225 } 01226 else 01227 { 01228 } 01229 } 01230 01231 void clear() 01232 { 01233 m_classList.clear(); 01234 m_classList.append(new Ctx); 01235 } 01236 01237 ClassDef *getClass() const 01238 { 01239 Ctx *ctx = m_classList.getLast(); 01240 01241 if (ctx) 01242 return ctx->cd; 01243 else 01244 return 0; 01245 } 01246 01247 private: 01248 QList<Ctx> m_classList; 01249 }; 01250 01251 static PyCallContext g_theCallContext; 01252 01253 01255 static int countLines() 01256 { 01257 const char *p=g_inputString; 01258 char c; 01259 int count=1; 01260 while ((c=*p)) 01261 { 01262 p++ ; 01263 if (c=='\n') count++; 01264 } 01265 if (p>g_inputString && *(p-1)!='\n') 01266 { // last line does not end with a \n, so we add an extra 01267 // line and explicitly terminate the line after parsing. 01268 count++, 01269 g_needsTermination=TRUE; 01270 } 01271 return count; 01272 } 01273 01274 static void setCurrentDoc(const QCString &name,const QCString &base,const QCString &anchor="") 01275 { 01276 static bool searchEngineEnabled=Config_getBool("SEARCHENGINE"); 01277 if (searchEngineEnabled) 01278 { 01279 Doxygen::searchIndex->setCurrentDoc(name,base,anchor); 01280 } 01281 } 01282 01283 static void addToSearchIndex(const char *text) 01284 { 01285 static bool searchEngineEnabled=Config_getBool("SEARCHENGINE"); 01286 if (searchEngineEnabled) 01287 { 01288 Doxygen::searchIndex->addWord(text,FALSE); 01289 } 01290 } 01291 01292 01293 static ClassDef *stripClassName(const char *s) 01294 { 01295 int pos=0; 01296 QCString type = s; 01297 QCString className; 01298 QCString templSpec; 01299 while (extractClassNameFromType(type,pos,className,templSpec)!=-1) 01300 { 01301 QCString clName=className+templSpec; 01302 01303 ClassDef *cd=0; 01304 if (!g_classScope.isEmpty()) 01305 { 01306 cd=getResolvedClass(g_currentDefinition,g_sourceFileDef,g_classScope+"::"+clName); 01307 } 01308 if (cd==0) 01309 { 01310 cd=getResolvedClass(g_currentDefinition,g_sourceFileDef,clName); 01311 } 01312 if (cd) 01313 { 01314 return cd; 01315 } 01316 } 01317 01318 return 0; 01319 } 01320 01321 01322 01327 static void startCodeLine() 01328 { 01329 //if (g_currentFontClass) { g_code->endFontClass(); } 01330 if (g_sourceFileDef) 01331 { 01332 //QCString lineNumber,lineAnchor; 01333 //lineNumber.sprintf("%05d",g_yyLineNr); 01334 //lineAnchor.sprintf("l%05d",g_yyLineNr); 01335 01336 Definition *d = g_sourceFileDef->getSourceDefinition(g_yyLineNr); 01337 //printf("startCodeLine %d d=%p\n",g_yyLineNr,d); 01338 //g_code->startLineNumber(); 01339 if (!g_includeCodeFragment && d && d->isLinkableInProject()) 01340 { 01341 g_currentDefinition = d; 01342 g_currentMemberDef = g_sourceFileDef->getSourceMember(g_yyLineNr); 01343 g_insideBody = FALSE; 01344 g_searchingForBody = TRUE; 01345 g_realScope = d->name().copy(); 01346 g_classScope = d->name().copy(); 01347 //printf("Real scope: `%s'\n",g_realScope.data()); 01348 g_bodyCurlyCount = 0; 01349 QCString lineAnchor; 01350 lineAnchor.sprintf("l%05d",g_yyLineNr); 01351 if (g_currentMemberDef) 01352 { 01353 g_code->writeLineNumber(g_currentMemberDef->getReference(), 01354 g_currentMemberDef->getOutputFileBase(), 01355 g_currentMemberDef->anchor(),g_yyLineNr); 01356 setCurrentDoc( 01357 g_currentMemberDef->qualifiedName(), 01358 g_sourceFileDef->getSourceFileBase(), 01359 lineAnchor); 01360 } 01361 else 01362 { 01363 g_code->writeLineNumber(d->getReference(), 01364 d->getOutputFileBase(), 01365 0,g_yyLineNr); 01366 setCurrentDoc( 01367 d->qualifiedName(), 01368 g_sourceFileDef->getSourceFileBase(), 01369 lineAnchor); 01370 } 01371 } 01372 else 01373 { 01374 //g_code->codify(lineNumber); 01375 g_code->writeLineNumber(0,0,0,g_yyLineNr); 01376 } 01377 //g_code->endLineNumber(); 01378 } 01379 g_code->startCodeLine(); 01380 if (g_currentFontClass) 01381 { 01382 g_code->startFontClass(g_currentFontClass); 01383 } 01384 } 01385 01386 static void codify(char* text) 01387 { 01388 g_code->codify(text); 01389 } 01390 01391 static void endCodeLine() 01392 { 01393 if (g_currentFontClass) { g_code->endFontClass(); } 01394 g_code->endCodeLine(); 01395 } 01396 01401 static void writeMultiLineCodeLink(CodeOutputInterface &ol, 01402 const char *ref,const char *file, 01403 const char *anchor,const char *text, 01404 const char *tooltip) 01405 { 01406 bool done=FALSE; 01407 char *p=(char *)text; 01408 while (!done) 01409 { 01410 char *sp=p; 01411 char c; 01412 while ((c=*p++) && c!='\n'); 01413 if (c=='\n') 01414 { 01415 g_yyLineNr++; 01416 *(p-1)='\0'; 01417 //printf("writeCodeLink(%s,%s,%s,%s)\n",ref,file,anchor,sp); 01418 ol.writeCodeLink(ref,file,anchor,sp,tooltip); 01419 endCodeLine(); 01420 if (g_yyLineNr<g_inputLines) 01421 { 01422 startCodeLine(); 01423 } 01424 } 01425 else 01426 { 01427 //printf("writeCodeLink(%s,%s,%s,%s)\n",ref,file,anchor,sp); 01428 ol.writeCodeLink(ref,file,anchor,sp,tooltip); 01429 done=TRUE; 01430 } 01431 } 01432 } 01433 01434 01435 static void codifyLines(char *text) 01436 { 01437 //printf("codifyLines(%d,\"%s\")\n",g_yyLineNr,text); 01438 char *p=text,*sp=p; 01439 char c; 01440 bool done=FALSE; 01441 while (!done) 01442 { 01443 sp=p; 01444 while ((c=*p++) && c!='\n'); 01445 if (c=='\n') 01446 { 01447 g_yyLineNr++; 01448 *(p-1)='\0'; 01449 g_code->codify(sp); 01450 endCodeLine(); 01451 if (g_yyLineNr<g_inputLines) 01452 { 01453 // Re-enable sometime 01454 startCodeLine(); 01455 } 01456 } 01457 else 01458 { 01459 g_code->codify(sp); 01460 done=TRUE; 01461 } 01462 } 01463 } 01464 01465 static void addDocCrossReference(MemberDef *src,MemberDef *dst) 01466 { 01467 if (dst->isTypedef() || dst->isEnumerate()) return; // don't add types 01468 //printf("addDocCrossReference src=%s,dst=%s\n",src->name().data(),dst->name().data()); 01469 if ((Config_getBool("REFERENCED_BY_RELATION") || Config_getBool("CALLER_GRAPH")) && 01470 (src->isFunction() || src->isSlot()) 01471 ) 01472 { 01473 dst->addSourceReferencedBy(src); 01474 } 01475 if ((Config_getBool("REFERENCES_RELATION") || Config_getBool("CALL_GRAPH")) && 01476 (src->isFunction() || src->isSlot()) 01477 ) 01478 { 01479 src->addSourceReferences(dst); 01480 } 01481 01482 } 01483 01484 01485 01486 static bool getLinkInScope(const QCString &c, // scope 01487 const QCString &m, // member 01488 const char *memberText, // exact text 01489 CodeOutputInterface &ol, 01490 const char *text 01491 ) 01492 { 01493 MemberDef *md; 01494 ClassDef *cd; 01495 FileDef *fd; 01496 NamespaceDef *nd; 01497 GroupDef *gd; 01498 //printf("Trying `%s'::`%s'\n",c.data(),m.data()); 01499 if (getDefs(c,m,"()",md,cd,fd,nd,gd,FALSE,g_sourceFileDef) && 01500 md->isLinkable()) 01501 { 01502 //printf("Found!\n"); 01503 //Definition *d=0; 01504 //if (cd) d=cd; else if (nd) d=nd; else if (fd) d=fd; else d=gd; 01505 01506 Definition *d = md->getOuterScope()==Doxygen::globalScope ? 01507 md->getBodyDef() : md->getOuterScope(); 01508 if (md->getGroupDef()) d = md->getGroupDef(); 01509 if (d && d->isLinkable()) 01510 { 01511 g_theCallContext.setClass(stripClassName(md->typeString())); 01512 //printf("g_currentDefinition=%p g_currentMemberDef=%p g_insideBody=%d\n", 01513 // g_currentDefinition,g_currentMemberDef,g_insideBody); 01514 01515 if (g_currentDefinition && g_currentMemberDef && 01516 md!=g_currentMemberDef && g_insideBody) 01517 { 01518 addDocCrossReference(g_currentMemberDef,md); 01519 } 01520 //printf("d->getReference()=`%s' d->getOutputBase()=`%s' name=`%s' member name=`%s'\n",d->getReference().data(),d->getOutputFileBase().data(),d->name().data(),md->name().data()); 01521 01522 writeMultiLineCodeLink(ol,md->getReference(), 01523 md->getOutputFileBase(), 01524 md->anchor(), 01525 text ? text : memberText, 01526 md->briefDescriptionAsTooltip()); 01527 addToSearchIndex(text ? text : memberText); 01528 return TRUE; 01529 } 01530 } 01531 return FALSE; 01532 } 01533 01534 static bool getLink(const char *className, 01535 const char *memberName, 01536 CodeOutputInterface &ol, 01537 const char *text=0) 01538 { 01539 QCString m=removeRedundantWhiteSpace(memberName); 01540 QCString c=className; 01541 if (!getLinkInScope(c,m,memberName,ol,text)) 01542 { 01543 if (!g_curClassName.isEmpty()) 01544 { 01545 if (!c.isEmpty()) c.prepend("::"); 01546 c.prepend(g_curClassName); 01547 return getLinkInScope(c,m,memberName,ol,text); 01548 } 01549 return FALSE; 01550 } 01551 return TRUE; 01552 } 01553 01554 01555 /* 01556 For a given string in the source code, 01557 finds its class or global id and links to it. 01558 01559 As of June 1, '05, this ONLY finds classes 01560 */ 01561 static void generateClassOrGlobalLink(CodeOutputInterface &ol,char *clName, 01562 bool /*typeOnly*/=FALSE) 01563 { 01564 QCString className=clName; 01565 01566 // Don't do anything for empty text 01567 if (className.isEmpty()) return; 01568 01569 ClassDef *cd=0,*lcd=0; 01570 MemberDef *md=0; 01571 bool isLocal=FALSE; 01572 01573 // printf("generateClassOrGlobalLink(className=%s)\n",className.data()); 01574 01575 if ((lcd=g_theVarContext.findVariable(className))==0) // not a local variable 01576 { 01577 Definition *d = g_currentDefinition; 01578 01579 cd = getResolvedClass(d,g_sourceFileDef,className,&md); 01580 01581 //printf("d=%p g_sourceFileDef=%p\n",d,g_currentDefinition); 01582 //printf("is found as a type %s\n",cd?cd->name().data():"<null>"); 01583 01584 if (cd==0 && md==0) // also see if it is variable or enum or enum value 01585 { 01586 if (getLink(g_classScope,clName,ol,clName)) 01587 { 01588 return; 01589 } 01590 } 01591 } 01592 else 01593 { 01594 if (lcd!=PyVariableContext::dummyContext) 01595 { 01596 g_theCallContext.setClass(lcd); 01597 } 01598 isLocal=TRUE; 01599 //fprintf(stderr,"is a local variable cd=%p!\n",cd); 01600 } 01601 01602 if (cd && cd->isLinkable()) // is it a linkable class 01603 { 01604 writeMultiLineCodeLink(ol,cd->getReference(),cd->getOutputFileBase(),0,clName,cd->briefDescriptionAsTooltip()); 01605 addToSearchIndex(className); 01606 if (md) 01607 { 01608 Definition *d = md->getOuterScope()==Doxygen::globalScope ? 01609 md->getBodyDef() : md->getOuterScope(); 01610 if (md->getGroupDef()) d = md->getGroupDef(); 01611 if (d && d->isLinkable() && md->isLinkable() && g_currentMemberDef) 01612 { 01613 addDocCrossReference(g_currentMemberDef,md); 01614 } 01615 } 01616 } 01617 else // not a class, maybe a global member 01618 { 01619 01620 /* 01621 This code requires a going-over in order to 01622 make it work for Python 01623 01624 //printf("class %s not linkable! cd=%p md=%p typeOnly=%d\n",clName,cd,md,typeOnly); 01625 if (!isLocal && (md!=0 || (cd==0 && !typeOnly))) // not a class, see if it is a global enum/variable/typedef. 01626 { 01627 if (md==0) // not found as a typedef 01628 { 01629 md = setCallContextForVar(clName); 01630 //printf("setCallContextForVar(%s) md=%p g_currentDefinition=%p\n",clName,md,g_currentDefinition); 01631 if (md && g_currentDefinition) 01632 { 01633 //fprintf(stderr,"%s accessible from %s? %d md->getOuterScope=%s\n", 01634 // md->name().data(),g_currentDefinition->name().data(), 01635 // isAccessibleFrom(g_currentDefinition,g_sourceFileDef,md), 01636 // md->getOuterScope()->name().data()); 01637 } 01638 01639 if (md && g_currentDefinition && 01640 isAccessibleFrom(g_currentDefinition,g_sourceFileDef,md)==-1) 01641 { 01642 md=0; // variable not accessible 01643 } 01644 } 01645 if (md) 01646 { 01647 //printf("is a global md=%p g_currentDefinition=%s\n",md,g_currentDefinition?g_currentDefinition->name().data():"<none>"); 01648 if (md->isLinkable()) 01649 { 01650 writeMultiLineCodeLink(ol,md->getReference(),md->getOutputFileBase(),md->anchor(),clName,md->briefDescriptionAsTooltip()); 01651 addToSearchIndex(clName); 01652 if (g_currentMemberDef) 01653 { 01654 addDocCrossReference(g_currentMemberDef,md); 01655 } 01656 return; 01657 } 01658 } 01659 } 01660 01661 */ 01662 01663 // nothing found, just write out the word 01664 codifyLines(clName); 01665 addToSearchIndex(clName); 01666 } 01667 } 01668 01669 /* 01670 As of June 1, this function seems to work 01671 for file members, but scopes are not 01672 being correctly tracked for classes 01673 so it doesn't work for classes yet. 01674 01675 */ 01676 static void generateFunctionLink(CodeOutputInterface &ol,char *funcName) 01677 { 01678 //CodeClassDef *ccd=0; 01679 ClassDef *ccd=0; 01680 QCString locScope=g_classScope.copy(); 01681 QCString locFunc=removeRedundantWhiteSpace(funcName); 01682 //fprintf(stdout,"*** locScope=%s locFunc=%s\n",locScope.data(),locFunc.data()); 01683 int i=locFunc.findRev("::"); 01684 if (i>0) 01685 { 01686 locScope=locFunc.left(i); 01687 locFunc=locFunc.right(locFunc.length()-i-2).stripWhiteSpace(); 01688 } 01689 //printf("generateFunctionLink(%s) classScope=`%s'\n",locFunc.data(),locScope.data()); 01690 if (!locScope.isEmpty() && (ccd=g_codeClassSDict[locScope])) 01691 { 01692 //printf("using classScope %s\n",g_classScope.data()); 01693 if (ccd->baseClasses()) 01694 { 01695 BaseClassListIterator bcli(*ccd->baseClasses()); 01696 for ( ; bcli.current() ; ++bcli) 01697 { 01698 if (getLink(bcli.current()->classDef->name(),locFunc,ol,funcName)) 01699 { 01700 return; 01701 } 01702 } 01703 } 01704 } 01705 if (!getLink(locScope,locFunc,ol,funcName)) 01706 { 01707 generateClassOrGlobalLink(ol,funcName); 01708 } 01709 return; 01710 } 01711 01712 static bool findMemberLink(CodeOutputInterface &ol,Definition *sym,const char *symName) 01713 { 01714 //printf("sym %s outerScope=%s equal=%d\n", 01715 // sym->name().data(),sym->getOuterScope()->name().data(), 01716 // sym->getOuterScope()==g_currentDefinition); 01717 01718 if (sym->getOuterScope() && 01719 sym->getOuterScope()->definitionType()==Definition::TypeClass && 01720 g_currentDefinition->definitionType()==Definition::TypeClass) 01721 { 01722 ClassDef *cd = (ClassDef*)sym->getOuterScope(); 01723 ClassDef *thisCd = (ClassDef *)g_currentDefinition; 01724 QCString anchor; 01725 if (sym->definitionType()==Definition::TypeMember) 01726 { 01727 anchor=((MemberDef *)sym)->anchor(); 01728 } 01729 01730 // TODO: find the nearest base class in case cd is a base class of 01731 // thisCd 01732 if (cd==thisCd) 01733 { 01734 writeMultiLineCodeLink(ol,sym->getReference(), 01735 sym->getOutputFileBase(), 01736 anchor, 01737 symName, 01738 sym->briefDescriptionAsTooltip()); 01739 return TRUE; 01740 } 01741 } 01742 return FALSE; 01743 } 01744 01745 static void findMemberLink(CodeOutputInterface &ol,char *symName) 01746 { 01747 //printf("Member reference: %s scope=%s member=%s\n", 01748 // pycodeYYtext, 01749 // g_currentDefinition?g_currentDefinition->name().data():"<none>", 01750 // g_currentMemberDef?g_currentMemberDef->name().data():"<none>" 01751 // ); 01752 if (g_currentDefinition) 01753 { 01754 DefinitionIntf *di = Doxygen::symbolMap->find(symName); 01755 if (di) 01756 { 01757 if (di->definitionType()==DefinitionIntf::TypeSymbolList) // multiple symbols 01758 { 01759 DefinitionListIterator dli(*(DefinitionList*)di); 01760 Definition *sym; 01761 for (dli.toFirst();(sym=dli.current());++dli) 01762 { 01763 if (findMemberLink(ol,sym,symName)) return; 01764 } 01765 } 01766 else // single symbol 01767 { 01768 if (findMemberLink(ol,(Definition*)di,symName)) return; 01769 } 01770 } 01771 } 01772 //printf("sym %s not found\n",&pycodeYYtext[5]); 01773 codify(symName); 01774 } 01775 01776 static void startFontClass(const char *s) 01777 { 01778 endFontClass(); 01779 g_code->startFontClass(s); 01780 g_currentFontClass=s; 01781 } 01782 01783 static void endFontClass() 01784 { 01785 if (g_currentFontClass) 01786 { 01787 g_code->endFontClass(); 01788 g_currentFontClass=0; 01789 } 01790 } 01791 01792 #undef YY_INPUT 01793 #define YY_INPUT(buf,result,max_size) result=yyread(buf,max_size); 01794 01795 static int yyread(char *buf,int max_size) 01796 { 01797 int c=0; 01798 while( c < max_size && g_inputString[g_inputPosition] ) 01799 { 01800 *buf = g_inputString[g_inputPosition++] ; 01801 c++; buf++; 01802 } 01803 return c; 01804 } 01805 01806 01807 01808 01809 01810 01811 01812 01813 01814 01815 01816 01817 01818 01819 01820 #line 1821 "<stdout>" 01821 01822 #define INITIAL 0 01823 #define Body 1 01824 #define FunctionDec 2 01825 #define FunctionParams 3 01826 #define ClassDec 4 01827 #define ClassInheritance 5 01828 #define Suite 6 01829 #define SuiteCaptureIndent 7 01830 #define SuiteStart 8 01831 #define SuiteMaintain 9 01832 #define SuiteContinuing 10 01833 #define LongString 11 01834 #define SingleQuoteString 12 01835 #define DoubleQuoteString 13 01836 #define TripleString 14 01837 01838 #ifndef YY_NO_UNISTD_H 01839 /* Special case for "unistd.h", since it is non-ANSI. We include it way 01840 * down here because we want the user's section 1 to have been scanned first. 01841 * The user has a chance to override it with an option. 01842 */ 01843 #include <unistd.h> 01844 #endif 01845 01846 #ifndef YY_EXTRA_TYPE 01847 #define YY_EXTRA_TYPE void * 01848 #endif 01849 01850 static int yy_init_globals (void ); 01851 01852 /* Macros after this point can all be overridden by user definitions in 01853 * section 1. 01854 */ 01855 01856 #ifndef YY_SKIP_YYWRAP 01857 #ifdef __cplusplus 01858 extern "C" int pycodeYYwrap (void ); 01859 #else 01860 extern int pycodeYYwrap (void ); 01861 #endif 01862 #endif 01863 01864 #ifndef yytext_ptr 01865 static void yy_flex_strncpy (char *,yyconst char *,int ); 01866 #endif 01867 01868 #ifdef YY_NEED_STRLEN 01869 static int yy_flex_strlen (yyconst char * ); 01870 #endif 01871 01872 #ifndef YY_NO_INPUT 01873 01874 #ifdef __cplusplus 01875 static int yyinput (void ); 01876 #else 01877 static int input (void ); 01878 #endif 01879 01880 #endif 01881 01882 /* Amount of stuff to slurp up with each read. */ 01883 #ifndef YY_READ_BUF_SIZE 01884 #define YY_READ_BUF_SIZE 8192 01885 #endif 01886 01887 /* Copy whatever the last rule matched to the standard output. */ 01888 #ifndef ECHO 01889 /* This used to be an fputs(), but since the string might contain NUL's, 01890 * we now use fwrite(). 01891 */ 01892 #define ECHO (void) fwrite( pycodeYYtext, pycodeYYleng, 1, pycodeYYout ) 01893 #endif 01894 01895 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 01896 * is returned in "result". 01897 */ 01898 #ifndef YY_INPUT 01899 #define YY_INPUT(buf,result,max_size) \ 01900 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 01901 { \ 01902 int c = '*'; \ 01903 size_t n; \ 01904 for ( n = 0; n < max_size && \ 01905 (c = getc( pycodeYYin )) != EOF && c != '\n'; ++n ) \ 01906 buf[n] = (char) c; \ 01907 if ( c == '\n' ) \ 01908 buf[n++] = (char) c; \ 01909 if ( c == EOF && ferror( pycodeYYin ) ) \ 01910 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 01911 result = n; \ 01912 } \ 01913 else \ 01914 { \ 01915 errno=0; \ 01916 while ( (result = fread(buf, 1, max_size, pycodeYYin))==0 && ferror(pycodeYYin)) \ 01917 { \ 01918 if( errno != EINTR) \ 01919 { \ 01920 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 01921 break; \ 01922 } \ 01923 errno=0; \ 01924 clearerr(pycodeYYin); \ 01925 } \ 01926 }\ 01927 \ 01928 01929 #endif 01930 01931 /* No semi-colon after return; correct usage is to write "yyterminate();" - 01932 * we don't want an extra ';' after the "return" because that will cause 01933 * some compilers to complain about unreachable statements. 01934 */ 01935 #ifndef yyterminate 01936 #define yyterminate() return YY_NULL 01937 #endif 01938 01939 /* Number of entries by which start-condition stack grows. */ 01940 #ifndef YY_START_STACK_INCR 01941 #define YY_START_STACK_INCR 25 01942 #endif 01943 01944 /* Report a fatal error. */ 01945 #ifndef YY_FATAL_ERROR 01946 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 01947 #endif 01948 01949 /* end tables serialization structures and prototypes */ 01950 01951 /* Default declaration of generated scanner - a define so the user can 01952 * easily add parameters. 01953 */ 01954 #ifndef YY_DECL 01955 #define YY_DECL_IS_OURS 1 01956 01957 extern int pycodeYYlex (void); 01958 01959 #define YY_DECL int pycodeYYlex (void) 01960 #endif /* !YY_DECL */ 01961 01962 /* Code executed at the beginning of each rule, after pycodeYYtext and pycodeYYleng 01963 * have been set up. 01964 */ 01965 #ifndef YY_USER_ACTION 01966 #define YY_USER_ACTION 01967 #endif 01968 01969 /* Code executed at the end of each rule. */ 01970 #ifndef YY_BREAK 01971 #define YY_BREAK break; 01972 #endif 01973 01974 #define YY_RULE_SETUP \ 01975 YY_USER_ACTION 01976 01979 YY_DECL 01980 { 01981 register yy_state_type yy_current_state; 01982 register char *yy_cp, *yy_bp; 01983 register int yy_act; 01984 01985 #line 948 "pycode.l" 01986 01987 01988 #line 1989 "<stdout>" 01989 01990 if ( !(yy_init) ) 01991 { 01992 (yy_init) = 1; 01993 01994 #ifdef YY_USER_INIT 01995 YY_USER_INIT; 01996 #endif 01997 01998 /* Create the reject buffer large enough to save one state per allowed character. */ 01999 if ( ! (yy_state_buf) ) 02000 (yy_state_buf) = (yy_state_type *)pycodeYYalloc(YY_STATE_BUF_SIZE ); 02001 02002 if ( ! (yy_start) ) 02003 (yy_start) = 1; /* first start state */ 02004 02005 if ( ! pycodeYYin ) 02006 pycodeYYin = stdin; 02007 02008 if ( ! pycodeYYout ) 02009 pycodeYYout = stdout; 02010 02011 if ( ! YY_CURRENT_BUFFER ) { 02012 pycodeYYensure_buffer_stack (); 02013 YY_CURRENT_BUFFER_LVALUE = 02014 pycodeYY_create_buffer(pycodeYYin,YY_BUF_SIZE ); 02015 } 02016 02017 pycodeYY_load_buffer_state( ); 02018 } 02019 02020 while ( 1 ) /* loops until end-of-file is reached */ 02021 { 02022 yy_cp = (yy_c_buf_p); 02023 02024 /* Support of pycodeYYtext. */ 02025 *yy_cp = (yy_hold_char); 02026 02027 /* yy_bp points to the position in yy_ch_buf of the start of 02028 * the current run. 02029 */ 02030 yy_bp = yy_cp; 02031 02032 yy_current_state = (yy_start); 02033 02034 (yy_state_ptr) = (yy_state_buf); 02035 *(yy_state_ptr)++ = yy_current_state; 02036 02037 yy_match: 02038 do 02039 { 02040 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 02041 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 02042 { 02043 yy_current_state = (int) yy_def[yy_current_state]; 02044 if ( yy_current_state >= 489 ) 02045 yy_c = yy_meta[(unsigned int) yy_c]; 02046 } 02047 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 02048 *(yy_state_ptr)++ = yy_current_state; 02049 ++yy_cp; 02050 } 02051 while ( yy_base[yy_current_state] != 1133 ); 02052 02053 yy_find_action: 02054 yy_current_state = *--(yy_state_ptr); 02055 (yy_lp) = yy_accept[yy_current_state]; 02056 find_rule: /* we branch to this label when backing up */ 02057 for ( ; ; ) /* until we find what rule we matched */ 02058 { 02059 if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] ) 02060 { 02061 yy_act = yy_acclist[(yy_lp)]; 02062 if ( yy_act & YY_TRAILING_HEAD_MASK || 02063 yy_looking_for_trail_begin ) 02064 { 02065 if ( yy_act == yy_looking_for_trail_begin ) 02066 { 02067 yy_looking_for_trail_begin = 0; 02068 yy_act &= ~YY_TRAILING_HEAD_MASK; 02069 break; 02070 } 02071 } 02072 else if ( yy_act & YY_TRAILING_MASK ) 02073 { 02074 yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK; 02075 yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK; 02076 (yy_full_match) = yy_cp; 02077 yy_full_state = (yy_state_ptr); 02078 yy_full_lp = (yy_lp); 02079 } 02080 else 02081 { 02082 (yy_full_match) = yy_cp; 02083 yy_full_state = (yy_state_ptr); 02084 yy_full_lp = (yy_lp); 02085 break; 02086 } 02087 ++(yy_lp); 02088 goto find_rule; 02089 } 02090 --yy_cp; 02091 yy_current_state = *--(yy_state_ptr); 02092 (yy_lp) = yy_accept[yy_current_state]; 02093 } 02094 02095 YY_DO_BEFORE_ACTION; 02096 02097 do_action: /* This label is used only to access EOF actions. */ 02098 02099 switch ( yy_act ) 02100 { /* beginning of action switch */ 02101 02102 case 1: 02103 YY_RULE_SETUP 02104 #line 951 "pycode.l" 02105 { 02106 startFontClass("keyword"); 02107 codify(pycodeYYtext); 02108 endFontClass(); 02109 BEGIN( FunctionDec ); 02110 } 02111 YY_BREAK 02112 case 2: 02113 YY_RULE_SETUP 02114 #line 958 "pycode.l" 02115 { 02116 startFontClass("keyword"); 02117 codify(pycodeYYtext); 02118 endFontClass(); 02119 BEGIN( ClassDec ); 02120 } 02121 YY_BREAK 02122 case 3: 02123 YY_RULE_SETUP 02124 #line 964 "pycode.l" 02125 { 02126 startFontClass("keywordtype"); 02127 codify(pycodeYYtext); 02128 endFontClass(); 02129 } 02130 YY_BREAK 02131 case 4: 02132 YY_RULE_SETUP 02133 #line 969 "pycode.l" 02134 { 02135 codify("self."); 02136 findMemberLink(*g_code,&pycodeYYtext[5]); 02137 } 02138 YY_BREAK 02139 02140 case 5: 02141 YY_RULE_SETUP 02142 #line 975 "pycode.l" 02143 { 02144 02145 generateClassOrGlobalLink(*g_code,pycodeYYtext); 02146 // codify(pycodeYYtext); 02147 g_curClassName = pycodeYYtext; 02148 g_curClassBases.clear(); 02149 BEGIN( ClassInheritance ); 02150 } 02151 YY_BREAK 02152 02153 case 6: 02154 YY_RULE_SETUP 02155 #line 985 "pycode.l" 02156 { 02157 codify(pycodeYYtext); 02158 } 02159 YY_BREAK 02160 case 7: 02161 YY_RULE_SETUP 02162 #line 989 "pycode.l" 02163 { 02164 // The parser 02165 // is assuming 02166 // that ALL identifiers 02167 // in this state 02168 // are base classes; 02169 // it doesn't check to see 02170 // that the first parenthesis 02171 // has been seen. 02172 02173 // This is bad - it should 02174 // probably be more strict 02175 // about what to accept. 02176 02177 g_curClassBases.inSort(pycodeYYtext); 02178 generateClassOrGlobalLink(*g_code,pycodeYYtext); 02179 // codify(pycodeYYtext); 02180 } 02181 YY_BREAK 02182 case 8: 02183 YY_RULE_SETUP 02184 #line 1008 "pycode.l" 02185 { 02186 codify(pycodeYYtext); 02187 02188 // Assume this will 02189 // be a one-line suite; 02190 // found counter-example 02191 // in SuiteStart. 02192 02193 // Push a class scope 02194 02195 ClassDef *classDefToAdd = new ClassDef("<code>",1,g_curClassName,ClassDef::Class,0,0,FALSE); 02196 g_codeClassSDict.append(g_curClassName,classDefToAdd); 02197 char *s=g_curClassBases.first(); 02198 while (s) 02199 { 02200 ClassDef *baseDefToAdd; 02201 baseDefToAdd=g_codeClassSDict[s]; 02202 02203 // Try to find class in global 02204 // scope 02205 if (baseDefToAdd==0) 02206 { 02207 baseDefToAdd=getResolvedClass(g_currentDefinition,g_sourceFileDef,s); 02208 } 02209 02210 if (baseDefToAdd && baseDefToAdd!=classDefToAdd) 02211 { 02212 classDefToAdd->insertBaseClass(baseDefToAdd,s,Public,Normal); 02213 } 02214 02215 s=g_curClassBases.next(); 02216 } 02217 02218 // Reset class-parsing variables. 02219 g_curClassName.resize(0); 02220 g_curClassBases.clear(); 02221 02222 g_noSuiteFound = TRUE; 02223 BEGIN( SuiteStart ); 02224 } 02225 YY_BREAK 02226 02227 02228 case 9: 02229 YY_RULE_SETUP 02230 #line 1052 "pycode.l" 02231 { 02232 generateFunctionLink(*g_code,pycodeYYtext); 02233 } 02234 YY_BREAK 02235 case 10: 02236 YY_RULE_SETUP 02237 #line 1056 "pycode.l" 02238 { 02239 codify(pycodeYYtext); 02240 BEGIN( FunctionParams ); 02241 } 02242 YY_BREAK 02243 02244 02245 case 11: 02246 YY_RULE_SETUP 02247 #line 1063 "pycode.l" 02248 { 02249 // Parses delimiters 02250 codify(pycodeYYtext); 02251 } 02252 YY_BREAK 02253 case 12: 02254 YY_RULE_SETUP 02255 #line 1068 "pycode.l" 02256 { 02257 codify(pycodeYYtext); 02258 } 02259 YY_BREAK 02260 case 13: 02261 YY_RULE_SETUP 02262 #line 1072 "pycode.l" 02263 { 02264 codify(pycodeYYtext); 02265 } 02266 YY_BREAK 02267 case 14: 02268 YY_RULE_SETUP 02269 #line 1076 "pycode.l" 02270 { 02271 codify(pycodeYYtext); 02272 02273 // Assume this will 02274 // be a one-line suite; 02275 // found counter-example 02276 // in SuiteStart. 02277 g_noSuiteFound = TRUE; 02278 BEGIN( SuiteStart ); 02279 } 02280 YY_BREAK 02281 02282 02283 case 15: 02284 YY_RULE_SETUP 02285 #line 1090 "pycode.l" 02286 { 02287 // Position-sensitive rules! 02288 // Must come AFTER keyword-triggered rules 02289 // Must come BEFORE identifier NONEMPTY-like rules 02290 // to syntax highlight. 02291 02292 startFontClass("keyword"); 02293 codify(pycodeYYtext); 02294 endFontClass(); 02295 } 02296 YY_BREAK 02297 case 16: 02298 YY_RULE_SETUP 02299 #line 1101 "pycode.l" 02300 { 02301 startFontClass("keywordflow"); 02302 codify(pycodeYYtext); 02303 endFontClass(); 02304 } 02305 YY_BREAK 02306 case 17: 02307 YY_RULE_SETUP 02308 #line 1107 "pycode.l" 02309 { 02310 codify(pycodeYYtext); 02311 } 02312 YY_BREAK 02313 02314 02315 case 18: 02316 YY_RULE_SETUP 02317 #line 1116 "pycode.l" 02318 { 02319 codify(pycodeYYtext); 02320 } 02321 YY_BREAK 02322 case 19: 02323 YY_RULE_SETUP 02324 #line 1119 "pycode.l" 02325 { 02326 startFontClass("keyword"); 02327 codifyLines(pycodeYYtext); 02328 endFontClass(); 02329 02330 // No indentation necesary 02331 g_noSuiteFound = FALSE; 02332 } 02333 YY_BREAK 02334 case 20: 02335 YY_RULE_SETUP 02336 #line 1128 "pycode.l" 02337 { 02338 startFontClass("keywordflow"); 02339 codifyLines(pycodeYYtext); 02340 endFontClass(); 02341 02342 // No indentation necesary 02343 g_noSuiteFound = FALSE; 02344 } 02345 YY_BREAK 02346 case 21: 02347 YY_RULE_SETUP 02348 #line 1136 "pycode.l" 02349 { 02350 codify(pycodeYYtext); 02351 } 02352 YY_BREAK 02353 case 22: 02354 YY_RULE_SETUP 02355 #line 1141 "pycode.l" 02356 { 02357 // This eats EVERYTHING 02358 // except the newline 02359 startFontClass("comment"); 02360 codifyLines(pycodeYYtext); 02361 endFontClass(); 02362 } 02363 YY_BREAK 02364 case 23: 02365 /* rule 23 can match eol */ 02366 YY_RULE_SETUP 02367 #line 1149 "pycode.l" 02368 { 02369 codifyLines(pycodeYYtext); 02370 if ( g_noSuiteFound ) 02371 { 02372 // printf("New suite to capture! [%d]\n", g_yyLineNr); 02373 BEGIN ( SuiteCaptureIndent ); 02374 } 02375 } 02376 YY_BREAK 02377 02378 02379 case 24: 02380 /* rule 24 can match eol */ 02381 YY_RULE_SETUP 02382 #line 1160 "pycode.l" 02383 { 02384 // Blankline - ignore, keep looking for indentation. 02385 codifyLines(pycodeYYtext); 02386 } 02387 YY_BREAK 02388 case 25: 02389 YY_RULE_SETUP 02390 #line 1165 "pycode.l" 02391 { 02392 // This state lasts momentarily, 02393 // to check the indentation 02394 // level that is about to be 02395 // used. 02396 codifyLines(pycodeYYtext); 02397 g_indents.push(pycodeYYleng); 02398 // printf("Captured indent of %d [line %d]\n", pycodeYYleng, g_yyLineNr); 02399 BEGIN( Suite ); 02400 } 02401 YY_BREAK 02402 02403 02404 case 26: 02405 YY_RULE_SETUP 02406 #line 1179 "pycode.l" 02407 { 02408 // This implements poor 02409 // indendation-tracking; 02410 // should be improved. 02411 // (translate tabs to space, etc) 02412 codifyLines(pycodeYYtext); 02413 adjustScopesAndSuites(pycodeYYleng); 02414 } 02415 YY_BREAK 02416 case 27: 02417 /* rule 27 can match eol */ 02418 YY_RULE_SETUP 02419 #line 1188 "pycode.l" 02420 { 02421 // If this ever succeeds, 02422 // it means that this is 02423 // a blank line, and 02424 // can be ignored. 02425 codifyLines(pycodeYYtext); 02426 } 02427 YY_BREAK 02428 case 28: 02429 YY_RULE_SETUP 02430 #line 1196 "pycode.l" 02431 { 02432 // Default rule; matches 02433 // the empty string, assuming 02434 // real text starts here. 02435 // Just go straight to Body. 02436 adjustScopesAndSuites(0); 02437 } 02438 YY_BREAK 02439 02440 case 29: 02441 /* rule 29 can match eol */ 02442 YY_RULE_SETUP 02443 #line 1206 "pycode.l" 02444 { 02445 codifyLines(pycodeYYtext); 02446 BEGIN( SuiteMaintain ); 02447 } 02448 YY_BREAK 02449 case 30: 02450 YY_RULE_SETUP 02451 #line 1210 "pycode.l" 02452 { 02453 codify(pycodeYYtext); 02454 } 02455 YY_BREAK 02456 case 31: 02457 /* rule 31 can match eol */ 02458 YY_RULE_SETUP 02459 #line 1213 "pycode.l" 02460 { 02461 codifyLines(pycodeYYtext); 02462 } 02463 YY_BREAK 02464 // Single quoted string like 'That\'s a """nice""" string!' 02465 case 32: 02466 /* rule 32 can match eol */ 02467 YY_RULE_SETUP 02468 #line 1218 "pycode.l" 02469 { // line continuation 02470 codifyLines(pycodeYYtext); 02471 } 02472 YY_BREAK 02473 case 33: 02474 YY_RULE_SETUP 02475 #line 1221 "pycode.l" 02476 { // espaced char 02477 codify(pycodeYYtext); 02478 } 02479 YY_BREAK 02480 case 34: 02481 YY_RULE_SETUP 02482 #line 1224 "pycode.l" 02483 { // tripple double quotes 02484 codify(pycodeYYtext); 02485 } 02486 YY_BREAK 02487 case 35: 02488 YY_RULE_SETUP 02489 #line 1227 "pycode.l" 02490 { // end of the string 02491 codify(pycodeYYtext); 02492 endFontClass(); 02493 BEGIN(g_stringContext); 02494 } 02495 YY_BREAK 02496 case 36: 02497 YY_RULE_SETUP 02498 #line 1232 "pycode.l" 02499 { // normal chars 02500 codify(pycodeYYtext); 02501 } 02502 YY_BREAK 02503 case 37: 02504 YY_RULE_SETUP 02505 #line 1235 "pycode.l" 02506 { // normal char 02507 codify(pycodeYYtext); 02508 } 02509 YY_BREAK 02510 02511 // Double quoted string like "That's \"a '''nice'''\" string!" 02512 case 38: 02513 /* rule 38 can match eol */ 02514 YY_RULE_SETUP 02515 #line 1241 "pycode.l" 02516 { // line continuation 02517 codifyLines(pycodeYYtext); 02518 } 02519 YY_BREAK 02520 case 39: 02521 YY_RULE_SETUP 02522 #line 1244 "pycode.l" 02523 { // espaced char 02524 codify(pycodeYYtext); 02525 } 02526 YY_BREAK 02527 case 40: 02528 YY_RULE_SETUP 02529 #line 1247 "pycode.l" 02530 { // tripple single quotes 02531 codify(pycodeYYtext); 02532 } 02533 YY_BREAK 02534 case 41: 02535 YY_RULE_SETUP 02536 #line 1250 "pycode.l" 02537 { // end of the string 02538 codify(pycodeYYtext); 02539 endFontClass(); 02540 BEGIN(g_stringContext); 02541 } 02542 YY_BREAK 02543 case 42: 02544 YY_RULE_SETUP 02545 #line 1255 "pycode.l" 02546 { // normal chars 02547 codify(pycodeYYtext); 02548 } 02549 YY_BREAK 02550 case 43: 02551 YY_RULE_SETUP 02552 #line 1258 "pycode.l" 02553 { // normal char 02554 codify(pycodeYYtext); 02555 } 02556 YY_BREAK 02557 02558 02559 case 44: 02560 #line 1265 "pycode.l" 02561 case 45: 02562 YY_RULE_SETUP 02563 #line 1265 "pycode.l" 02564 { 02565 codify(pycodeYYtext); 02566 if (g_doubleQuote==(pycodeYYtext[0]=='"')) 02567 { 02568 endFontClass(); 02569 BEGIN(g_stringContext); 02570 } 02571 } 02572 YY_BREAK 02573 case 46: 02574 /* rule 46 can match eol */ 02575 YY_RULE_SETUP 02576 #line 1273 "pycode.l" 02577 { 02578 codifyLines(pycodeYYtext); 02579 } 02580 YY_BREAK 02581 case 47: 02582 /* rule 47 can match eol */ 02583 YY_RULE_SETUP 02584 #line 1276 "pycode.l" 02585 { 02586 codifyLines(pycodeYYtext); 02587 } 02588 YY_BREAK 02589 case 48: 02590 YY_RULE_SETUP 02591 #line 1279 "pycode.l" 02592 { 02593 codify(pycodeYYtext); 02594 } 02595 YY_BREAK 02596 02597 /* 02598 <*>({NONEMPTY}|{EXPCHAR}|{BB}) { // This should go one character at a time. 02599 codify(pycodeYYtext); 02600 // printf("[pycode] '%s' [ state %d ] [line %d] no match\n", 02601 // pycodeYYtext, YY_START, g_yyLineNr); 02602 02603 //endFontClass(); 02604 BEGIN(Body); 02605 } 02606 */ 02607 case 49: 02608 #line 1296 "pycode.l" 02609 case 50: 02610 YY_RULE_SETUP 02611 #line 1296 "pycode.l" 02612 { 02613 startFontClass("stringliteral"); 02614 g_stringContext=YY_START; 02615 g_doubleQuote=pycodeYYtext[pycodeYYleng-1]=='"'; 02616 codify(pycodeYYtext); 02617 BEGIN(TripleString); 02618 } 02619 YY_BREAK 02620 case 51: 02621 YY_RULE_SETUP 02622 #line 1303 "pycode.l" 02623 { // single quoted string 02624 startFontClass("stringliteral"); 02625 g_stringContext=YY_START; 02626 codify(pycodeYYtext); 02627 BEGIN(SingleQuoteString); 02628 } 02629 YY_BREAK 02630 case 52: 02631 YY_RULE_SETUP 02632 #line 1309 "pycode.l" 02633 { // double quoted string 02634 startFontClass("stringliteral"); 02635 g_stringContext=YY_START; 02636 codify(pycodeYYtext); 02637 BEGIN(DoubleQuoteString); 02638 } 02639 YY_BREAK 02640 case 53: 02641 YY_RULE_SETUP 02642 #line 1315 "pycode.l" 02643 { 02644 if (YY_START==SingleQuoteString || 02645 YY_START==DoubleQuoteString || 02646 YY_START==TripleString 02647 ) 02648 { 02649 REJECT; 02650 } 02651 // This eats EVERYTHING 02652 // except the newline 02653 startFontClass("comment"); 02654 codifyLines(pycodeYYtext); 02655 endFontClass(); 02656 } 02657 YY_BREAK 02658 case 54: 02659 /* rule 54 can match eol */ 02660 YY_RULE_SETUP 02661 #line 1329 "pycode.l" 02662 { 02663 codifyLines(pycodeYYtext); 02664 //printf("[pycode] %d NEWLINE [line %d] no match\n", 02665 // YY_START, g_yyLineNr); 02666 02667 //endFontClass(); 02668 BEGIN(Body); 02669 } 02670 YY_BREAK 02671 case 55: 02672 YY_RULE_SETUP 02673 #line 1338 "pycode.l" 02674 { 02675 codify(pycodeYYtext); 02676 // printf("[pycode] '%s' [ state %d ] [line %d] no match\n", 02677 // pycodeYYtext, YY_START, g_yyLineNr); 02678 02679 //endFontClass(); 02680 BEGIN(Body); 02681 } 02682 YY_BREAK 02683 case 56: 02684 YY_RULE_SETUP 02685 #line 1347 "pycode.l" 02686 ECHO; 02687 YY_BREAK 02688 #line 2689 "<stdout>" 02689 case YY_STATE_EOF(INITIAL): 02690 case YY_STATE_EOF(Body): 02691 case YY_STATE_EOF(FunctionDec): 02692 case YY_STATE_EOF(FunctionParams): 02693 case YY_STATE_EOF(ClassDec): 02694 case YY_STATE_EOF(ClassInheritance): 02695 case YY_STATE_EOF(Suite): 02696 case YY_STATE_EOF(SuiteCaptureIndent): 02697 case YY_STATE_EOF(SuiteStart): 02698 case YY_STATE_EOF(SuiteMaintain): 02699 case YY_STATE_EOF(SuiteContinuing): 02700 case YY_STATE_EOF(LongString): 02701 case YY_STATE_EOF(SingleQuoteString): 02702 case YY_STATE_EOF(DoubleQuoteString): 02703 case YY_STATE_EOF(TripleString): 02704 yyterminate(); 02705 02706 case YY_END_OF_BUFFER: 02707 { 02708 /* Amount of text matched not including the EOB char. */ 02709 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; 02710 02711 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 02712 *yy_cp = (yy_hold_char); 02713 YY_RESTORE_YY_MORE_OFFSET 02714 02715 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 02716 { 02717 /* We're scanning a new file or input source. It's 02718 * possible that this happened because the user 02719 * just pointed pycodeYYin at a new source and called 02720 * pycodeYYlex(). If so, then we have to assure 02721 * consistency between YY_CURRENT_BUFFER and our 02722 * globals. Here is the right place to do so, because 02723 * this is the first action (other than possibly a 02724 * back-up) that will match for the new input source. 02725 */ 02726 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 02727 YY_CURRENT_BUFFER_LVALUE->yy_input_file = pycodeYYin; 02728 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 02729 } 02730 02731 /* Note that here we test for yy_c_buf_p "<=" to the position 02732 * of the first EOB in the buffer, since yy_c_buf_p will 02733 * already have been incremented past the NUL character 02734 * (since all states make transitions on EOB to the 02735 * end-of-buffer state). Contrast this with the test 02736 * in input(). 02737 */ 02738 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 02739 { /* This was really a NUL. */ 02740 yy_state_type yy_next_state; 02741 02742 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; 02743 02744 yy_current_state = yy_get_previous_state( ); 02745 02746 /* Okay, we're now positioned to make the NUL 02747 * transition. We couldn't have 02748 * yy_get_previous_state() go ahead and do it 02749 * for us because it doesn't know how to deal 02750 * with the possibility of jamming (and we don't 02751 * want to build jamming into it because then it 02752 * will run more slowly). 02753 */ 02754 02755 yy_next_state = yy_try_NUL_trans( yy_current_state ); 02756 02757 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 02758 02759 if ( yy_next_state ) 02760 { 02761 /* Consume the NUL. */ 02762 yy_cp = ++(yy_c_buf_p); 02763 yy_current_state = yy_next_state; 02764 goto yy_match; 02765 } 02766 02767 else 02768 { 02769 yy_cp = (yy_c_buf_p); 02770 goto yy_find_action; 02771 } 02772 } 02773 02774 else switch ( yy_get_next_buffer( ) ) 02775 { 02776 case EOB_ACT_END_OF_FILE: 02777 { 02778 (yy_did_buffer_switch_on_eof) = 0; 02779 02780 if ( pycodeYYwrap( ) ) 02781 { 02782 /* Note: because we've taken care in 02783 * yy_get_next_buffer() to have set up 02784 * pycodeYYtext, we can now set up 02785 * yy_c_buf_p so that if some total 02786 * hoser (like flex itself) wants to 02787 * call the scanner after we return the 02788 * YY_NULL, it'll still work - another 02789 * YY_NULL will get returned. 02790 */ 02791 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; 02792 02793 yy_act = YY_STATE_EOF(YY_START); 02794 goto do_action; 02795 } 02796 02797 else 02798 { 02799 if ( ! (yy_did_buffer_switch_on_eof) ) 02800 YY_NEW_FILE; 02801 } 02802 break; 02803 } 02804 02805 case EOB_ACT_CONTINUE_SCAN: 02806 (yy_c_buf_p) = 02807 (yytext_ptr) + yy_amount_of_matched_text; 02808 02809 yy_current_state = yy_get_previous_state( ); 02810 02811 yy_cp = (yy_c_buf_p); 02812 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 02813 goto yy_match; 02814 02815 case EOB_ACT_LAST_MATCH: 02816 (yy_c_buf_p) = 02817 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; 02818 02819 yy_current_state = yy_get_previous_state( ); 02820 02821 yy_cp = (yy_c_buf_p); 02822 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 02823 goto yy_find_action; 02824 } 02825 break; 02826 } 02827 02828 default: 02829 YY_FATAL_ERROR( 02830 "fatal flex scanner internal error--no action found" ); 02831 } /* end of action switch */ 02832 } /* end of scanning one token */ 02833 } /* end of pycodeYYlex */ 02834 02835 /* yy_get_next_buffer - try to read in a new buffer 02836 * 02837 * Returns a code representing an action: 02838 * EOB_ACT_LAST_MATCH - 02839 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 02840 * EOB_ACT_END_OF_FILE - end of file 02841 */ 02842 static int yy_get_next_buffer (void) 02843 { 02844 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 02845 register char *source = (yytext_ptr); 02846 register int number_to_move, i; 02847 int ret_val; 02848 02849 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) 02850 YY_FATAL_ERROR( 02851 "fatal flex scanner internal error--end of buffer missed" ); 02852 02853 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 02854 { /* Don't try to fill the buffer, so this is an EOF. */ 02855 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) 02856 { 02857 /* We matched a single character, the EOB, so 02858 * treat this as a final EOF. 02859 */ 02860 return EOB_ACT_END_OF_FILE; 02861 } 02862 02863 else 02864 { 02865 /* We matched some text prior to the EOB, first 02866 * process it. 02867 */ 02868 return EOB_ACT_LAST_MATCH; 02869 } 02870 } 02871 02872 /* Try to read more data. */ 02873 02874 /* First move last chars to start of buffer. */ 02875 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; 02876 02877 for ( i = 0; i < number_to_move; ++i ) 02878 *(dest++) = *(source++); 02879 02880 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 02881 /* don't do the read, it's not guaranteed to return an EOF, 02882 * just force an EOF 02883 */ 02884 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; 02885 02886 else 02887 { 02888 int num_to_read = 02889 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 02890 02891 while ( num_to_read <= 0 ) 02892 { /* Not enough room in the buffer - grow it. */ 02893 02894 YY_FATAL_ERROR( 02895 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 02896 02897 } 02898 02899 if ( num_to_read > YY_READ_BUF_SIZE ) 02900 num_to_read = YY_READ_BUF_SIZE; 02901 02902 /* Read in more data. */ 02903 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 02904 (yy_n_chars), num_to_read ); 02905 02906 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 02907 } 02908 02909 if ( (yy_n_chars) == 0 ) 02910 { 02911 if ( number_to_move == YY_MORE_ADJ ) 02912 { 02913 ret_val = EOB_ACT_END_OF_FILE; 02914 pycodeYYrestart(pycodeYYin ); 02915 } 02916 02917 else 02918 { 02919 ret_val = EOB_ACT_LAST_MATCH; 02920 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 02921 YY_BUFFER_EOF_PENDING; 02922 } 02923 } 02924 02925 else 02926 ret_val = EOB_ACT_CONTINUE_SCAN; 02927 02928 (yy_n_chars) += number_to_move; 02929 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; 02930 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; 02931 02932 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 02933 02934 return ret_val; 02935 } 02936 02937 /* yy_get_previous_state - get the state just before the EOB char was reached */ 02938 02939 static yy_state_type yy_get_previous_state (void) 02940 { 02941 register yy_state_type yy_current_state; 02942 register char *yy_cp; 02943 02944 yy_current_state = (yy_start); 02945 02946 (yy_state_ptr) = (yy_state_buf); 02947 *(yy_state_ptr)++ = yy_current_state; 02948 02949 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) 02950 { 02951 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 02952 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 02953 { 02954 yy_current_state = (int) yy_def[yy_current_state]; 02955 if ( yy_current_state >= 489 ) 02956 yy_c = yy_meta[(unsigned int) yy_c]; 02957 } 02958 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 02959 *(yy_state_ptr)++ = yy_current_state; 02960 } 02961 02962 return yy_current_state; 02963 } 02964 02965 /* yy_try_NUL_trans - try to make a transition on the NUL character 02966 * 02967 * synopsis 02968 * next_state = yy_try_NUL_trans( current_state ); 02969 */ 02970 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) 02971 { 02972 register int yy_is_jam; 02973 02974 register YY_CHAR yy_c = 1; 02975 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 02976 { 02977 yy_current_state = (int) yy_def[yy_current_state]; 02978 if ( yy_current_state >= 489 ) 02979 yy_c = yy_meta[(unsigned int) yy_c]; 02980 } 02981 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 02982 yy_is_jam = (yy_current_state == 488); 02983 if ( ! yy_is_jam ) 02984 *(yy_state_ptr)++ = yy_current_state; 02985 02986 return yy_is_jam ? 0 : yy_current_state; 02987 } 02988 02989 #ifndef YY_NO_INPUT 02990 #ifdef __cplusplus 02991 static int yyinput (void) 02992 #else 02993 static int input (void) 02994 #endif 02995 02996 { 02997 int c; 02998 02999 *(yy_c_buf_p) = (yy_hold_char); 03000 03001 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) 03002 { 03003 /* yy_c_buf_p now points to the character we want to return. 03004 * If this occurs *before* the EOB characters, then it's a 03005 * valid NUL; if not, then we've hit the end of the buffer. 03006 */ 03007 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 03008 /* This was really a NUL. */ 03009 *(yy_c_buf_p) = '\0'; 03010 03011 else 03012 { /* need more input */ 03013 int offset = (yy_c_buf_p) - (yytext_ptr); 03014 ++(yy_c_buf_p); 03015 03016 switch ( yy_get_next_buffer( ) ) 03017 { 03018 case EOB_ACT_LAST_MATCH: 03019 /* This happens because yy_g_n_b() 03020 * sees that we've accumulated a 03021 * token and flags that we need to 03022 * try matching the token before 03023 * proceeding. But for input(), 03024 * there's no matching to consider. 03025 * So convert the EOB_ACT_LAST_MATCH 03026 * to EOB_ACT_END_OF_FILE. 03027 */ 03028 03029 /* Reset buffer status. */ 03030 pycodeYYrestart(pycodeYYin ); 03031 03032 /*FALLTHROUGH*/ 03033 03034 case EOB_ACT_END_OF_FILE: 03035 { 03036 if ( pycodeYYwrap( ) ) 03037 return 0; 03038 03039 if ( ! (yy_did_buffer_switch_on_eof) ) 03040 YY_NEW_FILE; 03041 #ifdef __cplusplus 03042 return yyinput(); 03043 #else 03044 return input(); 03045 #endif 03046 } 03047 03048 case EOB_ACT_CONTINUE_SCAN: 03049 (yy_c_buf_p) = (yytext_ptr) + offset; 03050 break; 03051 } 03052 } 03053 } 03054 03055 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ 03056 *(yy_c_buf_p) = '\0'; /* preserve pycodeYYtext */ 03057 (yy_hold_char) = *++(yy_c_buf_p); 03058 03059 return c; 03060 } 03061 #endif /* ifndef YY_NO_INPUT */ 03062 03068 void pycodeYYrestart (FILE * input_file ) 03069 { 03070 03071 if ( ! YY_CURRENT_BUFFER ){ 03072 pycodeYYensure_buffer_stack (); 03073 YY_CURRENT_BUFFER_LVALUE = 03074 pycodeYY_create_buffer(pycodeYYin,YY_BUF_SIZE ); 03075 } 03076 03077 pycodeYY_init_buffer(YY_CURRENT_BUFFER,input_file ); 03078 pycodeYY_load_buffer_state( ); 03079 } 03080 03085 void pycodeYY_switch_to_buffer (YY_BUFFER_STATE new_buffer ) 03086 { 03087 03088 /* TODO. We should be able to replace this entire function body 03089 * with 03090 * pycodeYYpop_buffer_state(); 03091 * pycodeYYpush_buffer_state(new_buffer); 03092 */ 03093 pycodeYYensure_buffer_stack (); 03094 if ( YY_CURRENT_BUFFER == new_buffer ) 03095 return; 03096 03097 if ( YY_CURRENT_BUFFER ) 03098 { 03099 /* Flush out information for old buffer. */ 03100 *(yy_c_buf_p) = (yy_hold_char); 03101 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 03102 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 03103 } 03104 03105 YY_CURRENT_BUFFER_LVALUE = new_buffer; 03106 pycodeYY_load_buffer_state( ); 03107 03108 /* We don't actually know whether we did this switch during 03109 * EOF (pycodeYYwrap()) processing, but the only time this flag 03110 * is looked at is after pycodeYYwrap() is called, so it's safe 03111 * to go ahead and always set it. 03112 */ 03113 (yy_did_buffer_switch_on_eof) = 1; 03114 } 03115 03116 static void pycodeYY_load_buffer_state (void) 03117 { 03118 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 03119 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 03120 pycodeYYin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 03121 (yy_hold_char) = *(yy_c_buf_p); 03122 } 03123 03130 YY_BUFFER_STATE pycodeYY_create_buffer (FILE * file, int size ) 03131 { 03132 YY_BUFFER_STATE b; 03133 03134 b = (YY_BUFFER_STATE) pycodeYYalloc(sizeof( struct yy_buffer_state ) ); 03135 if ( ! b ) 03136 YY_FATAL_ERROR( "out of dynamic memory in pycodeYY_create_buffer()" ); 03137 03138 b->yy_buf_size = size; 03139 03140 /* yy_ch_buf has to be 2 characters longer than the size given because 03141 * we need to put in 2 end-of-buffer characters. 03142 */ 03143 b->yy_ch_buf = (char *) pycodeYYalloc(b->yy_buf_size + 2 ); 03144 if ( ! b->yy_ch_buf ) 03145 YY_FATAL_ERROR( "out of dynamic memory in pycodeYY_create_buffer()" ); 03146 03147 b->yy_is_our_buffer = 1; 03148 03149 pycodeYY_init_buffer(b,file ); 03150 03151 return b; 03152 } 03153 03158 void pycodeYY_delete_buffer (YY_BUFFER_STATE b ) 03159 { 03160 03161 if ( ! b ) 03162 return; 03163 03164 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 03165 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 03166 03167 if ( b->yy_is_our_buffer ) 03168 pycodeYYfree((void *) b->yy_ch_buf ); 03169 03170 pycodeYYfree((void *) b ); 03171 } 03172 03173 #ifndef __cplusplus 03174 extern int isatty (int ); 03175 #endif /* __cplusplus */ 03176 03177 /* Initializes or reinitializes a buffer. 03178 * This function is sometimes called more than once on the same buffer, 03179 * such as during a pycodeYYrestart() or at EOF. 03180 */ 03181 static void pycodeYY_init_buffer (YY_BUFFER_STATE b, FILE * file ) 03182 03183 { 03184 int oerrno = errno; 03185 03186 pycodeYY_flush_buffer(b ); 03187 03188 b->yy_input_file = file; 03189 b->yy_fill_buffer = 1; 03190 03191 /* If b is the current buffer, then pycodeYY_init_buffer was _probably_ 03192 * called from pycodeYYrestart() or through yy_get_next_buffer. 03193 * In that case, we don't want to reset the lineno or column. 03194 */ 03195 if (b != YY_CURRENT_BUFFER){ 03196 b->yy_bs_lineno = 1; 03197 b->yy_bs_column = 0; 03198 } 03199 03200 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 03201 03202 errno = oerrno; 03203 } 03204 03209 void pycodeYY_flush_buffer (YY_BUFFER_STATE b ) 03210 { 03211 if ( ! b ) 03212 return; 03213 03214 b->yy_n_chars = 0; 03215 03216 /* We always need two end-of-buffer characters. The first causes 03217 * a transition to the end-of-buffer state. The second causes 03218 * a jam in that state. 03219 */ 03220 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 03221 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 03222 03223 b->yy_buf_pos = &b->yy_ch_buf[0]; 03224 03225 b->yy_at_bol = 1; 03226 b->yy_buffer_status = YY_BUFFER_NEW; 03227 03228 if ( b == YY_CURRENT_BUFFER ) 03229 pycodeYY_load_buffer_state( ); 03230 } 03231 03238 void pycodeYYpush_buffer_state (YY_BUFFER_STATE new_buffer ) 03239 { 03240 if (new_buffer == NULL) 03241 return; 03242 03243 pycodeYYensure_buffer_stack(); 03244 03245 /* This block is copied from pycodeYY_switch_to_buffer. */ 03246 if ( YY_CURRENT_BUFFER ) 03247 { 03248 /* Flush out information for old buffer. */ 03249 *(yy_c_buf_p) = (yy_hold_char); 03250 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 03251 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 03252 } 03253 03254 /* Only push if top exists. Otherwise, replace top. */ 03255 if (YY_CURRENT_BUFFER) 03256 (yy_buffer_stack_top)++; 03257 YY_CURRENT_BUFFER_LVALUE = new_buffer; 03258 03259 /* copied from pycodeYY_switch_to_buffer. */ 03260 pycodeYY_load_buffer_state( ); 03261 (yy_did_buffer_switch_on_eof) = 1; 03262 } 03263 03268 void pycodeYYpop_buffer_state (void) 03269 { 03270 if (!YY_CURRENT_BUFFER) 03271 return; 03272 03273 pycodeYY_delete_buffer(YY_CURRENT_BUFFER ); 03274 YY_CURRENT_BUFFER_LVALUE = NULL; 03275 if ((yy_buffer_stack_top) > 0) 03276 --(yy_buffer_stack_top); 03277 03278 if (YY_CURRENT_BUFFER) { 03279 pycodeYY_load_buffer_state( ); 03280 (yy_did_buffer_switch_on_eof) = 1; 03281 } 03282 } 03283 03284 /* Allocates the stack if it does not exist. 03285 * Guarantees space for at least one push. 03286 */ 03287 static void pycodeYYensure_buffer_stack (void) 03288 { 03289 int num_to_alloc; 03290 03291 if (!(yy_buffer_stack)) { 03292 03293 /* First allocation is just for 2 elements, since we don't know if this 03294 * scanner will even need a stack. We use 2 instead of 1 to avoid an 03295 * immediate realloc on the next call. 03296 */ 03297 num_to_alloc = 1; 03298 (yy_buffer_stack) = (struct yy_buffer_state**)pycodeYYalloc 03299 (num_to_alloc * sizeof(struct yy_buffer_state*) 03300 ); 03301 03302 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 03303 03304 (yy_buffer_stack_max) = num_to_alloc; 03305 (yy_buffer_stack_top) = 0; 03306 return; 03307 } 03308 03309 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ 03310 03311 /* Increase the buffer to prepare for a possible push. */ 03312 int grow_size = 8 /* arbitrary grow size */; 03313 03314 num_to_alloc = (yy_buffer_stack_max) + grow_size; 03315 (yy_buffer_stack) = (struct yy_buffer_state**)pycodeYYrealloc 03316 ((yy_buffer_stack), 03317 num_to_alloc * sizeof(struct yy_buffer_state*) 03318 ); 03319 03320 /* zero only the new slots.*/ 03321 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 03322 (yy_buffer_stack_max) = num_to_alloc; 03323 } 03324 } 03325 03332 YY_BUFFER_STATE pycodeYY_scan_buffer (char * base, yy_size_t size ) 03333 { 03334 YY_BUFFER_STATE b; 03335 03336 if ( size < 2 || 03337 base[size-2] != YY_END_OF_BUFFER_CHAR || 03338 base[size-1] != YY_END_OF_BUFFER_CHAR ) 03339 /* They forgot to leave room for the EOB's. */ 03340 return 0; 03341 03342 b = (YY_BUFFER_STATE) pycodeYYalloc(sizeof( struct yy_buffer_state ) ); 03343 if ( ! b ) 03344 YY_FATAL_ERROR( "out of dynamic memory in pycodeYY_scan_buffer()" ); 03345 03346 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 03347 b->yy_buf_pos = b->yy_ch_buf = base; 03348 b->yy_is_our_buffer = 0; 03349 b->yy_input_file = 0; 03350 b->yy_n_chars = b->yy_buf_size; 03351 b->yy_is_interactive = 0; 03352 b->yy_at_bol = 1; 03353 b->yy_fill_buffer = 0; 03354 b->yy_buffer_status = YY_BUFFER_NEW; 03355 03356 pycodeYY_switch_to_buffer(b ); 03357 03358 return b; 03359 } 03360 03369 YY_BUFFER_STATE pycodeYY_scan_string (yyconst char * yystr ) 03370 { 03371 03372 return pycodeYY_scan_bytes(yystr,strlen(yystr) ); 03373 } 03374 03382 YY_BUFFER_STATE pycodeYY_scan_bytes (yyconst char * yybytes, int _yybytes_len ) 03383 { 03384 YY_BUFFER_STATE b; 03385 char *buf; 03386 yy_size_t n; 03387 int i; 03388 03389 /* Get memory for full buffer, including space for trailing EOB's. */ 03390 n = _yybytes_len + 2; 03391 buf = (char *) pycodeYYalloc(n ); 03392 if ( ! buf ) 03393 YY_FATAL_ERROR( "out of dynamic memory in pycodeYY_scan_bytes()" ); 03394 03395 for ( i = 0; i < _yybytes_len; ++i ) 03396 buf[i] = yybytes[i]; 03397 03398 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 03399 03400 b = pycodeYY_scan_buffer(buf,n ); 03401 if ( ! b ) 03402 YY_FATAL_ERROR( "bad buffer in pycodeYY_scan_bytes()" ); 03403 03404 /* It's okay to grow etc. this buffer, and we should throw it 03405 * away when we're done. 03406 */ 03407 b->yy_is_our_buffer = 1; 03408 03409 return b; 03410 } 03411 03412 #ifndef YY_EXIT_FAILURE 03413 #define YY_EXIT_FAILURE 2 03414 #endif 03415 03416 static void yy_fatal_error (yyconst char* msg ) 03417 { 03418 (void) fprintf( stderr, "%s\n", msg ); 03419 exit( YY_EXIT_FAILURE ); 03420 } 03421 03422 /* Redefine yyless() so it works in section 3 code. */ 03423 03424 #undef yyless 03425 #define yyless(n) \ 03426 do \ 03427 { \ 03428 /* Undo effects of setting up pycodeYYtext. */ \ 03429 int yyless_macro_arg = (n); \ 03430 YY_LESS_LINENO(yyless_macro_arg);\ 03431 pycodeYYtext[pycodeYYleng] = (yy_hold_char); \ 03432 (yy_c_buf_p) = pycodeYYtext + yyless_macro_arg; \ 03433 (yy_hold_char) = *(yy_c_buf_p); \ 03434 *(yy_c_buf_p) = '\0'; \ 03435 pycodeYYleng = yyless_macro_arg; \ 03436 } \ 03437 while ( 0 ) 03438 03439 /* Accessor methods (get/set functions) to struct members. */ 03440 03444 int pycodeYYget_lineno (void) 03445 { 03446 03447 return pycodeYYlineno; 03448 } 03449 03453 FILE *pycodeYYget_in (void) 03454 { 03455 return pycodeYYin; 03456 } 03457 03461 FILE *pycodeYYget_out (void) 03462 { 03463 return pycodeYYout; 03464 } 03465 03469 int pycodeYYget_leng (void) 03470 { 03471 return pycodeYYleng; 03472 } 03473 03478 char *pycodeYYget_text (void) 03479 { 03480 return pycodeYYtext; 03481 } 03482 03487 void pycodeYYset_lineno (int line_number ) 03488 { 03489 03490 pycodeYYlineno = line_number; 03491 } 03492 03499 void pycodeYYset_in (FILE * in_str ) 03500 { 03501 pycodeYYin = in_str ; 03502 } 03503 03504 void pycodeYYset_out (FILE * out_str ) 03505 { 03506 pycodeYYout = out_str ; 03507 } 03508 03509 int pycodeYYget_debug (void) 03510 { 03511 return pycodeYY_flex_debug; 03512 } 03513 03514 void pycodeYYset_debug (int bdebug ) 03515 { 03516 pycodeYY_flex_debug = bdebug ; 03517 } 03518 03519 static int yy_init_globals (void) 03520 { 03521 /* Initialization is the same as for the non-reentrant scanner. 03522 * This function is called from pycodeYYlex_destroy(), so don't allocate here. 03523 */ 03524 03525 (yy_buffer_stack) = 0; 03526 (yy_buffer_stack_top) = 0; 03527 (yy_buffer_stack_max) = 0; 03528 (yy_c_buf_p) = (char *) 0; 03529 (yy_init) = 0; 03530 (yy_start) = 0; 03531 03532 (yy_state_buf) = 0; 03533 (yy_state_ptr) = 0; 03534 (yy_full_match) = 0; 03535 (yy_lp) = 0; 03536 03537 /* Defined in main.c */ 03538 #ifdef YY_STDINIT 03539 pycodeYYin = stdin; 03540 pycodeYYout = stdout; 03541 #else 03542 pycodeYYin = (FILE *) 0; 03543 pycodeYYout = (FILE *) 0; 03544 #endif 03545 03546 /* For future reference: Set errno on error, since we are called by 03547 * pycodeYYlex_init() 03548 */ 03549 return 0; 03550 } 03551 03552 /* pycodeYYlex_destroy is for both reentrant and non-reentrant scanners. */ 03553 int pycodeYYlex_destroy (void) 03554 { 03555 03556 /* Pop the buffer stack, destroying each element. */ 03557 while(YY_CURRENT_BUFFER){ 03558 pycodeYY_delete_buffer(YY_CURRENT_BUFFER ); 03559 YY_CURRENT_BUFFER_LVALUE = NULL; 03560 pycodeYYpop_buffer_state(); 03561 } 03562 03563 /* Destroy the stack itself. */ 03564 pycodeYYfree((yy_buffer_stack) ); 03565 (yy_buffer_stack) = NULL; 03566 03567 pycodeYYfree ( (yy_state_buf) ); 03568 (yy_state_buf) = NULL; 03569 03570 /* Reset the globals. This is important in a non-reentrant scanner so the next time 03571 * pycodeYYlex() is called, initialization will occur. */ 03572 yy_init_globals( ); 03573 03574 return 0; 03575 } 03576 03577 /* 03578 * Internal utility routines. 03579 */ 03580 03581 #ifndef yytext_ptr 03582 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) 03583 { 03584 register int i; 03585 for ( i = 0; i < n; ++i ) 03586 s1[i] = s2[i]; 03587 } 03588 #endif 03589 03590 #ifdef YY_NEED_STRLEN 03591 static int yy_flex_strlen (yyconst char * s ) 03592 { 03593 register int n; 03594 for ( n = 0; s[n]; ++n ) 03595 ; 03596 03597 return n; 03598 } 03599 #endif 03600 03601 void *pycodeYYalloc (yy_size_t size ) 03602 { 03603 return (void *) malloc( size ); 03604 } 03605 03606 void *pycodeYYrealloc (void * ptr, yy_size_t size ) 03607 { 03608 /* The cast to (char *) in the following accommodates both 03609 * implementations that use char* generic pointers, and those 03610 * that use void* generic pointers. It works with the latter 03611 * because both ANSI C and C++ allow castless assignment from 03612 * any pointer type to void*, and deal with argument conversions 03613 * as though doing an assignment. 03614 */ 03615 return (void *) realloc( (char *) ptr, size ); 03616 } 03617 03618 void pycodeYYfree (void * ptr ) 03619 { 03620 free( (char *) ptr ); /* see pycodeYYrealloc() for (char *) cast */ 03621 } 03622 03623 #define YYTABLES_NAME "yytables" 03624 03625 #line 1347 "pycode.l" 03626 03627 03628 03629 /*@ ---------------------------------------------------------------------------- 03630 */ 03631 03632 void resetPythonCodeParserState() 03633 { 03634 g_currentDefinition = 0; 03635 g_currentMemberDef = 0; 03636 g_doubleStringIsDoc = FALSE; 03637 g_paramParens = 0; 03638 g_indents.clear(); 03639 BEGIN( Body ); 03640 } 03641 03646 static void adjustScopesAndSuites(unsigned indentLength) 03647 { 03648 // States to pop 03649 if (!g_indents.isEmpty() && indentLength < g_indents.top()) 03650 { 03651 while (!g_indents.isEmpty() && indentLength < g_indents.top()) 03652 { 03653 // printf("Exited scope indent of [%d]\n", g_indents.top()); 03654 g_indents.pop(); // Pop the old suite's indentation 03655 03656 g_currentMemberDef=0; 03657 if (g_currentDefinition) 03658 g_currentDefinition=g_currentDefinition->getOuterScope(); 03659 } 03660 } 03661 03662 // Are there any remaining indentation levels for suites? 03663 if (!g_indents.isEmpty()) 03664 { 03665 BEGIN( Suite ); 03666 } 03667 else 03668 { 03669 BEGIN( Body ); 03670 } 03671 } 03672 03673 void parsePythonCode(CodeOutputInterface &od,const char *className, 03674 const QCString &s,bool exBlock, const char *exName, 03675 FileDef *fd,int startLine,int endLine,bool inlineFragment, 03676 MemberDef *) 03677 { 03678 03679 //printf("***parseCode()\n"); 03680 03681 //--- some code to eliminate warnings--- 03682 className = ""; 03683 exBlock = FALSE; 03684 exName = ""; 03685 inlineFragment = ""; 03686 //-------------------------------------- 03687 if (s.isEmpty()) return; 03688 g_code = &od; 03689 g_inputString = s; 03690 g_inputPosition = 0; 03691 g_currentFontClass = 0; 03692 g_needsTermination = FALSE; 03693 if (endLine!=-1) 03694 g_inputLines = endLine+1; 03695 else 03696 g_inputLines = countLines(); 03697 03698 if (startLine!=-1) 03699 g_yyLineNr = startLine; 03700 else 03701 g_yyLineNr = 1; 03702 03703 g_exampleBlock = exBlock; 03704 g_exampleName = exName; 03705 g_sourceFileDef = fd; 03706 03707 03708 // Starts line 1 on the output 03709 startCodeLine(); 03710 03711 pycodeYYrestart( pycodeYYin ); 03712 03713 pycodeYYlex(); 03714 03715 if (!g_indents.isEmpty()) 03716 { 03717 // printf("Exited pysourceparser in inconsistent state!\n"); 03718 } 03719 03720 if (g_needsTermination) 03721 { 03722 endFontClass(); 03723 g_code->endCodeLine(); 03724 } 03725 return; 03726 } 03727 03728 03729 #if !defined(YY_FLEX_SUBMINOR_VERSION) 03730 extern "C" { // some bogus code to keep the compiler happy 03731 void pycodeYYdummy() { yy_flex_realloc(0,0); } 03732 } 03733 #elif YY_FLEX_SUBMINOR_VERSION<33 03734 #error "You seem to be using a version of flex newer than 2.5.4. These are currently incompatible with 2.5.4, and do NOT work with doxygen! Please use version 2.5.4 or expect things to be parsed wrongly! A bug report has been submitted (#732132)." 03735 #endif 03736 03737
1.5.1