pyscanner.cpp

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



Generated on Mon Mar 31 10:58:42 2008 by  doxygen 1.5.1