src/defargs.cpp

   1
   2 #line 3 "<stdout>"
   3
   4 #define  YY_INT_ALIGNED short int
   5
   6 /* A lexical scanner generated by flex */
   7
   8 #define yy_create_buffer defargsYY_create_buffer
   9 #define yy_delete_buffer defargsYY_delete_buffer
  10 #define yy_flex_debug defargsYY_flex_debug
  11 #define yy_init_buffer defargsYY_init_buffer
  12 #define yy_flush_buffer defargsYY_flush_buffer
  13 #define yy_load_buffer_state defargsYY_load_buffer_state
  14 #define yy_switch_to_buffer defargsYY_switch_to_buffer
  15 #define yyin defargsYYin
  16 #define yyleng defargsYYleng
  17 #define yylex defargsYYlex
  18 #define yylineno defargsYYlineno
  19 #define yyout defargsYYout
  20 #define yyrestart defargsYYrestart
  21 #define yytext defargsYYtext
  22 #define yywrap defargsYYwrap
  23 #define yyalloc defargsYYalloc
  24 #define yyrealloc defargsYYrealloc
  25 #define yyfree defargsYYfree
  26
  27 #define FLEX_SCANNER
  28 #define YY_FLEX_MAJOR_VERSION 2
  29 #define YY_FLEX_MINOR_VERSION 5
  30 #define YY_FLEX_SUBMINOR_VERSION 35
  31 #if YY_FLEX_SUBMINOR_VERSION > 0
  32 #define FLEX_BETA
  33 #endif
  34
  35 /* First, we deal with  platform-specific or compiler-specific issues. */
  36
  37 /* begin standard C headers. */
  38 #include <stdio.h>
  39 #include <string.h>
  40 #include <errno.h>
  41 #include <stdlib.h>
  42
  43 /* end standard C headers. */
  44
  45 /* flex integer type definitions */
  46
  47 #ifndef FLEXINT_H
  48 #define FLEXINT_H
  49
  50 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  51
  52 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  53
  54 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  55  * if you want the limit (max/min) macros for int types.
  56  */
  57 #ifndef __STDC_LIMIT_MACROS
  58 #define __STDC_LIMIT_MACROS 1
  59 #endif
  60
  61 #include <inttypes.h>
  62 typedef int8_t flex_int8_t;
  63 typedef uint8_t flex_uint8_t;
  64 typedef int16_t flex_int16_t;
  65 typedef uint16_t flex_uint16_t;
  66 typedef int32_t flex_int32_t;
  67 typedef uint32_t flex_uint32_t;
  68 typedef uint64_t flex_uint64_t;
  69 #else
  70 typedef signed char flex_int8_t;
  71 typedef short int flex_int16_t;
  72 typedef int flex_int32_t;
  73 typedef unsigned char flex_uint8_t;
  74 typedef unsigned short int flex_uint16_t;
  75 typedef unsigned int flex_uint32_t;
  76 #endif /* ! C99 */
  77
  78 /* Limits of integral types. */
  79 #ifndef INT8_MIN
  80 #define INT8_MIN               (-128)
  81 #endif
  82 #ifndef INT16_MIN
  83 #define INT16_MIN              (-32767-1)
  84 #endif
  85 #ifndef INT32_MIN
  86 #define INT32_MIN              (-2147483647-1)
  87 #endif
  88 #ifndef INT8_MAX
  89 #define INT8_MAX               (127)
  90 #endif
  91 #ifndef INT16_MAX
  92 #define INT16_MAX              (32767)
  93 #endif
  94 #ifndef INT32_MAX
  95 #define INT32_MAX              (2147483647)
  96 #endif
  97 #ifndef UINT8_MAX
  98 #define UINT8_MAX              (255U)
  99 #endif
 100 #ifndef UINT16_MAX
 101 #define UINT16_MAX             (65535U)
 102 #endif
 103 #ifndef UINT32_MAX
 104 #define UINT32_MAX             (4294967295U)
 105 #endif
 106
 107 #endif /* ! FLEXINT_H */
 108
 109 #ifdef __cplusplus
 110
 111 /* The "const" storage-class-modifier is valid. */
 112 #define YY_USE_CONST
 113
 114 #else   /* ! __cplusplus */
 115
 116 /* C99 requires __STDC__ to be defined as 1. */
 117 #if defined (__STDC__)
 118
 119 #define YY_USE_CONST
 120
 121 #endif  /* defined (__STDC__) */
 122 #endif  /* ! __cplusplus */
 123
 124 #ifdef YY_USE_CONST
 125 #define yyconst const
 126 #else
 127 #define yyconst
 128 #endif
 129
 130 /* Returned upon end-of-file. */
 131 #define YY_NULL 0
 132
 133 /* Promotes a possibly negative, possibly signed char to an unsigned
 134  * integer for use as an array index.  If the signed char is negative,
 135  * we want to instead treat it as an 8-bit unsigned char, hence the
 136  * double cast.
 137  */
 138 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 139
 140 /* Enter a start condition.  This macro really ought to take a parameter,
 141  * but we do it the disgusting crufty way forced on us by the ()-less
 142  * definition of BEGIN.
 143  */
 144 #define BEGIN (yy_start) = 1 + 2 *
 145
 146 /* Translate the current start state into a value that can be later handed
 147  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 148  * compatibility.
 149  */
 150 #define YY_START (((yy_start) - 1) / 2)
 151 #define YYSTATE YY_START
 152
 153 /* Action number for EOF rule of a given start state. */
 154 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 155
 156 /* Special action meaning "start processing a new file". */
 157 #define YY_NEW_FILE defargsYYrestart(defargsYYin  )
 158
 159 #define YY_END_OF_BUFFER_CHAR 0
 160
 161 /* Size of default input buffer. */
 162 #ifndef YY_BUF_SIZE
 163 #define YY_BUF_SIZE 262144
 164 #endif
 165
 166 /* The state buf must be large enough to hold one state per character in the main buffer.
 167  */
 168 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 169
 170 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 171 #define YY_TYPEDEF_YY_BUFFER_STATE
 172 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 173 #endif
 174
 175 #ifndef YY_TYPEDEF_YY_SIZE_T
 176 #define YY_TYPEDEF_YY_SIZE_T
 177 typedef size_t yy_size_t;
 178 #endif
 179
 180 extern yy_size_t defargsYYleng;
 181
 182 extern FILE *defargsYYin, *defargsYYout;
 183
 184 #define EOB_ACT_CONTINUE_SCAN 0
 185 #define EOB_ACT_END_OF_FILE 1
 186 #define EOB_ACT_LAST_MATCH 2
 187
 188     #define YY_LESS_LINENO(n)
 189
 190 /* Return all but the first "n" matched characters back to the input stream. */
 191 #define yyless(n) \
 192         do \
 193                 { \
 194                 /* Undo effects of setting up defargsYYtext. */ \
 195         int yyless_macro_arg = (n); \
 196         YY_LESS_LINENO(yyless_macro_arg);\
 197                 *yy_cp = (yy_hold_char); \
 198                 YY_RESTORE_YY_MORE_OFFSET \
 199                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 200                 YY_DO_BEFORE_ACTION; /* set up defargsYYtext again */ \
 201                 } \
 202         while ( 0 )
 203
 204 #define unput(c) yyunput( c, (yytext_ptr)  )
 205
 206 #ifndef YY_STRUCT_YY_BUFFER_STATE
 207 #define YY_STRUCT_YY_BUFFER_STATE
 208 struct yy_buffer_state
 209         {
 210         FILE *yy_input_file;
 211
 212         char *yy_ch_buf;                /* input buffer */
 213         char *yy_buf_pos;               /* current position in input buffer */
 214
 215         /* Size of input buffer in bytes, not including room for EOB
 216          * characters.
 217          */
 218         yy_size_t yy_buf_size;
 219
 220         /* Number of characters read into yy_ch_buf, not including EOB
 221          * characters.
 222          */
 223         yy_size_t yy_n_chars;
 224
 225         /* Whether we "own" the buffer - i.e., we know we created it,
 226          * and can realloc() it to grow it, and should free() it to
 227          * delete it.
 228          */
 229         int yy_is_our_buffer;
 230
 231         /* Whether this is an "interactive" input source; if so, and
 232          * if we're using stdio for input, then we want to use getc()
 233          * instead of fread(), to make sure we stop fetching input after
 234          * each newline.
 235          */
 236         int yy_is_interactive;
 237
 238         /* Whether we're considered to be at the beginning of a line.
 239          * If so, '^' rules will be active on the next match, otherwise
 240          * not.
 241          */
 242         int yy_at_bol;
 243
 244     int yy_bs_lineno; /**< The line count. */
 245     int yy_bs_column; /**< The column count. */
 246
 247         /* Whether to try to fill the input buffer when we reach the
 248          * end of it.
 249          */
 250         int yy_fill_buffer;
 251
 252         int yy_buffer_status;
 253
 254 #define YY_BUFFER_NEW 0
 255 #define YY_BUFFER_NORMAL 1
 256         /* When an EOF's been seen but there's still some text to process
 257          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 258          * shouldn't try reading from the input source any more.  We might
 259          * still have a bunch of tokens to match, though, because of
 260          * possible backing-up.
 261          *
 262          * When we actually see the EOF, we change the status to "new"
 263          * (via defargsYYrestart()), so that the user can continue scanning by
 264          * just pointing defargsYYin at a new input file.
 265          */
 266 #define YY_BUFFER_EOF_PENDING 2
 267
 268         };
 269 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 270
 271 /* Stack of input buffers. */
 272 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
 273 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
 274 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 275
 276 /* We provide macros for accessing buffer states in case in the
 277  * future we want to put the buffer states in a more general
 278  * "scanner state".
 279  *
 280  * Returns the top of the stack, or NULL.
 281  */
 282 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
 283                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
 284                           : NULL)
 285
 286 /* Same as previous macro, but useful when we know that the buffer stack is not
 287  * NULL or when we need an lvalue. For internal use only.
 288  */
 289 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 290
 291 /* yy_hold_char holds the character lost when defargsYYtext is formed. */
 292 static char yy_hold_char;
 293 static yy_size_t yy_n_chars;            /* number of characters read into yy_ch_buf */
 294 yy_size_t defargsYYleng;
 295
 296 /* Points to current character in buffer. */
 297 static char *yy_c_buf_p = (char *) 0;
 298 static int yy_init = 0;         /* whether we need to initialize */
 299 static int yy_start = 0;        /* start state number */
 300
 301 /* Flag which is used to allow defargsYYwrap()'s to do buffer switches
 302  * instead of setting up a fresh defargsYYin.  A bit of a hack ...
 303  */
 304 static int yy_did_buffer_switch_on_eof;
 305
 306 void defargsYYrestart (FILE *input_file  );
 307 void defargsYY_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 308 YY_BUFFER_STATE defargsYY_create_buffer (FILE *file,int size  );
 309 void defargsYY_delete_buffer (YY_BUFFER_STATE b  );
 310 void defargsYY_flush_buffer (YY_BUFFER_STATE b  );
 311 void defargsYYpush_buffer_state (YY_BUFFER_STATE new_buffer  );
 312 void defargsYYpop_buffer_state (void );
 313
 314 static void defargsYYensure_buffer_stack (void );
 315 static void defargsYY_load_buffer_state (void );
 316 static void defargsYY_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 317
 318 #define YY_FLUSH_BUFFER defargsYY_flush_buffer(YY_CURRENT_BUFFER )
 319
 320 YY_BUFFER_STATE defargsYY_scan_buffer (char *base,yy_size_t size  );
 321 YY_BUFFER_STATE defargsYY_scan_string (yyconst char *yy_str  );
 322 YY_BUFFER_STATE defargsYY_scan_bytes (yyconst char *bytes,yy_size_t len  );
 323
 324 void *defargsYYalloc (yy_size_t  );
 325 void *defargsYYrealloc (void *,yy_size_t  );
 326 void defargsYYfree (void *  );
 327
 328 #define yy_new_buffer defargsYY_create_buffer
 329
 330 #define yy_set_interactive(is_interactive) \
 331         { \
 332         if ( ! YY_CURRENT_BUFFER ){ \
 333         defargsYYensure_buffer_stack (); \
 334                 YY_CURRENT_BUFFER_LVALUE =    \
 335             defargsYY_create_buffer(defargsYYin,YY_BUF_SIZE ); \
 336         } \
 337         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 338         }
 339
 340 #define yy_set_bol(at_bol) \
 341         { \
 342         if ( ! YY_CURRENT_BUFFER ){\
 343         defargsYYensure_buffer_stack (); \
 344                 YY_CURRENT_BUFFER_LVALUE =    \
 345             defargsYY_create_buffer(defargsYYin,YY_BUF_SIZE ); \
 346         } \
 347         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 348         }
 349
 350 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 351
 352 /* Begin user sect3 */
 353
 354 #define defargsYYwrap(n) 1
 355 #define YY_SKIP_YYWRAP
 356
 357 typedef unsigned char YY_CHAR;
 358
 359 FILE *defargsYYin = (FILE *) 0, *defargsYYout = (FILE *) 0;
 360
 361 typedef int yy_state_type;
 362
 363 extern int defargsYYlineno;
 364
 365 int defargsYYlineno = 1;
 366
 367 extern char *defargsYYtext;
 368 #define yytext_ptr defargsYYtext
 369
 370 static yy_state_type yy_get_previous_state (void );
 371 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 372 static int yy_get_next_buffer (void );
 373 static void yy_fatal_error (yyconst char msg[]  );
 374
 375 /* Done after the current pattern has been matched and before the
 376  * corresponding action - sets up defargsYYtext.
 377  */
 378 #define YY_DO_BEFORE_ACTION \
 379         (yytext_ptr) = yy_bp; \
 380         defargsYYleng = (yy_size_t) (yy_cp - yy_bp); \
 381         (yy_hold_char) = *yy_cp; \
 382         *yy_cp = '\0'; \
 383         (yy_c_buf_p) = yy_cp;
 384
 385 #define YY_NUM_RULES 52
 386 #define YY_END_OF_BUFFER 53
 387 /* This struct is not used in this scanner,
 388    but its presence is necessary. */
 389 struct yy_trans_info
 390         {
 391         flex_int32_t yy_verify;
 392         flex_int32_t yy_nxt;
 393         };
 394 static yyconst flex_int16_t yy_acclist[274] =
 395     {   0,
 396         2,    2,   53,   51,   52,   50,   52,   51,   52,    1,
 397        51,   52,   32,   51,   52,   25,   32,   51,   52,   32,
 398        51,   52,   32,   51,   52,   32,   51,   52,   32,   51,
 399        52,   32,   51,   52,   34,   51,   52,   16,   34,   51,
 400        52,   17,   18,   34,   51,   52,   34,   51,   52,   33,
 401        34,   51,   52,   17,   34,   51,   52,   19,   34,   51,
 402        52,   20,   34,   51,   52,   21,   34,   51,   52,   22,
 403        34,   51,   52,   30,   51,   52,    2,   30,   51,   52,
 404        30,   51,   52,   15,   30,   51,   52,   28,   30,   51,
 405        52,   30,   51,   52,   30,   51,   52,   15,   30,   51,
 406
 407        52,   26,   30,   51,   52,   28,   30,   51,   52,   29,
 408        30,   51,   52,   30,   51,   52,   15,   30,   51,   52,
 409         8,   32,   51,   52,   32,   51,   52,   15,   32,   51,
 410        52,   28,   32,   51,   52,   28,   32,   51,   52,   32,
 411        51,   52,   32,   51,   52,   32,   51,   52,   13,   30,
 412        51,   52,   10,   29,   30,   51,   52,   51,   52,   51,
 413        52,   51,   52,   51,   52,   51,   52,   43,   48,   51,
 414        52,   47,   50,   52,   48,   51,   52,   43,   48,   51,
 415        52,   44,   51,   52,   46,   50,   52,   44,   51,   52,
 416        40,   51,   52,   40,   51,   52,   41,   50,   52,   40,
 417
 418        51,   52,   40,   51,   52,   31,   23,   24,   18,   17,
 419        33,    2,   29,16393,   14,   29,    3,   11,   12,   10,
 420        29,   38,   37,   43,   45,   43,   44,   44,   44,   49,
 421        24,   17,   17,16393, 8201,    6,    6,    7,   42,   43,
 422        49,   44,   49,   49,   24, 8201,    5,    4,    5,   43,
 423        49,   44,   49,   24,   27,    4,   35,   24,   39,   24,
 424        39,   24,   36,   24,   24,   24,   24,   24,   24,   24,
 425        24,   24,   24
 426     } ;
 427
 428 static yyconst flex_int16_t yy_accept[238] =
 429     {   0,
 430         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 431         1,    1,    1,    1,    1,    1,    1,    2,    3,    3,
 432         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 433         3,    4,    6,    8,   10,   13,   16,   20,   23,   26,
 434        29,   32,   35,   38,   42,   47,   50,   54,   58,   62,
 435        66,   70,   74,   77,   81,   84,   88,   92,   95,   98,
 436       102,  106,  110,  114,  117,  121,  125,  128,  132,  136,
 437       140,  143,  146,  149,  153,  158,  160,  162,  164,  166,
 438       168,  172,  175,  178,  182,  185,  188,  191,  194,  197,
 439       200,  203,  206,  206,  206,  207,  208,  208,  209,  210,
 440
 441       211,  212,  212,  213,  214,  214,  214,  215,  215,  215,
 442       216,  217,  217,  218,  218,  218,  218,  218,  218,  218,
 443       219,  220,  222,  222,  222,  223,  223,  224,  224,  224,
 444       225,  226,  227,  228,  229,  230,  230,  230,  231,  231,
 445       232,  233,  234,  234,  234,  234,  235,  236,  236,  236,
 446       237,  237,  238,  238,  238,  239,  239,  240,  240,  240,
 447       242,  244,  244,  244,  245,  245,  246,  246,  247,  247,
 448       248,  250,  250,  250,  250,  250,  252,  254,  254,  254,
 449       254,  255,  256,  257,  257,  257,  258,  258,  258,  258,
 450       258,  259,  259,  259,  260,  260,  260,  261,  261,  261,
 451
 452       262,  262,  262,  263,  263,  264,  264,  264,  265,  265,
 453       265,  266,  266,  266,  267,  267,  267,  268,  268,  268,
 454       269,  269,  269,  270,  270,  270,  271,  271,  271,  272,
 455       272,  272,  273,  273,  274,  274,  274
 456     } ;
 457
 458 static yyconst flex_int32_t yy_ec[256] =
 459     {   0,
 460         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 461         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 462         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 463         1,    2,    4,    5,    1,    6,    1,    7,    8,    9,
 464        10,   11,    1,   12,   13,    1,   14,   15,   16,   16,
 465        16,   16,   16,   16,   16,   17,   18,   19,    1,   20,
 466        21,   22,    1,    1,   23,   23,   23,   23,   23,   23,
 467        23,   23,   23,   23,   23,   24,   23,   23,   23,   23,
 468        23,   25,   23,   23,   26,   23,   23,   23,   23,   23,
 469        27,   28,   29,    7,   23,    1,   30,   23,   31,   32,
 470
 471        33,   34,   23,   23,   35,   23,   23,   36,   23,   37,
 472        38,   23,   23,   39,   40,   41,   42,   43,   23,   23,
 473        23,   23,   44,    1,   45,    1,    1,   23,   23,   23,
 474        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
 475        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
 476        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
 477        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
 478        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
 479        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
 480        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
 481
 482        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
 483        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
 484        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
 485        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
 486        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
 487        23,   23,   23,   23,   23
 488     } ;
 489
 490 static yyconst flex_int32_t yy_meta[46] =
 491     {   0,
 492         1,    2,    3,    1,    1,    1,    1,    1,    4,    5,
 493         6,    1,    1,    1,    7,    7,    7,    7,    8,    1,
 494         1,    1,    9,    9,    9,    9,    1,   10,    1,    9,
 495         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 496         9,    9,    9,    1,    1
 497     } ;
 498
 499 static yyconst flex_int16_t yy_base[288] =
 500     {   0,
 501         0,    1,    2,    3,    5,   21,   18,   26,   49,    0,
 502       757,  751,   86,   89,   91,   93,  138,    0,  181,    0,
 503       225,    0,  268,  309,   27,   28,    6,   34,  102,  110,
 504       758,  883,  883,   33,  883,  883,  883,  730,   96,   24,
 505         0,  746,  883,  883,  747,  103,    0,  741,  883,  883,
 506       883,  883,  883,  738,    0,  118,   11,  712,  104,  101,
 507       883,  190,    0,  704,  883,  883,  703,  883,  183,  194,
 508       700,  717,  102,  270,    0,  186,  694,  185,  677,  675,
 509         0,  883,  693,  119,    0,  883,  188,  883,   94,  883,
 510       203,  207,  269,  206,  883,  883,  699,  693,  695,  275,
 511
 512         0,  693,  687,    0,  281,  294,  351,  272,  207,  883,
 513         0,  657,  883,  672,  279,  674,  668,  646,  300,  883,
 514       883,    0,  283,  639,  883,  273,  883,  625,  625,    0,
 515       883,  294,    0,  303,  302,  624,  610,  630,  639,  638,
 516       316,    0,  301,  622,  335,  310,  394,  324,  311,  883,
 517       627,  624,  328,  617,  883,  596,  883,  583,  577,  584,
 518       575,  554,  556,  883,  583,  582,  348,    0,  566,  883,
 519       883,  333,  571,  538,  536,    0,    0,  538,  522,  553,
 520       549,  883,  883,  537,  522,  883,  492,  488,  479,  510,
 521       509,  504,  476,  509,  475,  499,  498,  492,  459,  402,
 522
 523       348,  374,  373,  364,  883,  339,  366,  364,  359,  362,
 524       361,  356,  359,  358,  352,  355,  352,  347,  346,  342,
 525       336,  334,  333,  320,  321,  319,  295,  279,  271,  215,
 526       214,  193,  125,  883,  117,  883,  439,  449,  459,  469,
 527       479,  489,  499,  507,  510,   88,  519,  523,  532,  542,
 528       546,  555,  565,  575,  583,  592,  602,  611,  621,  630,
 529       639,  648,  657,  666,  675,  684,  693,  702,  711,  720,
 530       729,  738,  747,  756,  765,  774,  783,  792,  801,  810,
 531       819,  828,  837,  846,  855,  864,  873
 532     } ;
 533
 534 static yyconst flex_int16_t yy_def[288] =
 535     {   0,
 536       237,  237,  237,  237,  238,  238,  238,  238,  236,    9,
 537         9,    9,    9,    9,    9,    9,  236,   17,  238,   19,
 538       236,   21,  237,  237,  239,  239,  240,  240,  241,  241,
 539       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
 540       242,  243,  236,  236,  244,  236,  245,  244,  236,  236,
 541       236,  236,  236,  236,  246,  247,  236,  236,  236,  236,
 542       236,  236,  248,  249,  236,  236,  250,  236,  236,  236,
 543       236,  236,  236,  236,  251,  236,  236,  236,  236,  236,
 544       252,  236,  236,  252,  253,  236,  253,  236,  236,  236,
 545       236,  236,  236,  236,  236,  236,  254,  254,  244,  255,
 546
 547       245,  244,  236,  248,  247,  247,  247,  236,  236,  236,
 548       248,  249,  236,  236,  256,  236,  257,  236,  236,  236,
 549       236,  251,  236,  258,  236,  236,  236,  236,  236,  252,
 550       236,  252,  253,  253,  253,  236,  236,  236,  259,  259,
 551       255,  141,  247,  236,  247,  107,  236,  236,  236,  236,
 552       236,  236,  236,  260,  236,  258,  236,  236,  236,  252,
 553       253,  236,  236,  236,  261,  261,  247,  147,  236,  236,
 554       236,  236,  262,  236,  236,  252,  253,  236,  236,  263,
 555       263,  236,  236,  236,  264,  236,  236,  236,  236,  265,
 556       265,  266,  236,  236,  236,  267,  267,  268,  236,  236,
 557
 558       236,  269,  269,  270,  236,  236,  271,  271,  272,  273,
 559       273,  274,  275,  275,  276,  277,  277,  278,  279,  279,
 560       280,  281,  281,  282,  283,  283,  284,  285,  285,  286,
 561       236,  236,  287,  236,  236,    0,  236,  236,  236,  236,
 562       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
 563       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
 564       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
 565       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
 566       236,  236,  236,  236,  236,  236,  236
 567     } ;
 568
 569 static yyconst flex_int16_t yy_nxt[929] =
 570     {   0,
 571       236,  236,   33,   33,   33,   33,  236,   33,   86,   37,
 572        35,   35,  108,   34,   34,   34,   34,   38,   39,   87,
 573        33,   35,   35,   33,  109,   37,   40,   42,   33,   82,
 574        82,   39,   41,   38,   39,   42,   86,   83,   83,   39,
 575        84,   84,   40,   93,   95,   95,   94,   87,   41,   43,
 576        43,   33,   43,   43,   43,   43,   43,   44,   45,   43,
 577        43,   43,   46,   43,   43,   43,   43,   43,   43,   43,
 578        43,   47,   47,   47,   47,   43,   43,   43,   47,   47,
 579        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
 580        47,   47,   43,   43,   43,   43,  104,   43,   43,   43,
 581
 582        43,   43,   43,   89,   90,   49,   93,   50,   49,   94,
 583        50,   89,   90,   93,   93,   91,   94,   94,  118,  106,
 584       110,  110,   92,   91,  107,  155,  116,  136,  107,   93,
 585        92,  137,  132,  155,   51,   52,   51,   52,   53,   54,
 586        33,   53,   53,   55,   53,   53,   56,   57,   53,   57,
 587        58,   59,   53,   53,   53,   53,   53,   60,   61,   62,
 588        63,   63,   63,   63,   64,   53,   53,   63,   63,   63,
 589        63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
 590        63,   65,   53,   33,  108,   66,  126,  123,   67,   68,
 591        69,  108,   69,   38,   39,  108,  109,  234,  134,  127,
 592
 593        68,  135,   70,  109,   71,   72,   71,  109,  126,  138,
 594       110,  110,  124,   93,   95,   95,   94,  148,  234,  138,
 595       149,  127,   73,  155,   68,   53,   53,   33,   53,   53,
 596        55,   53,   53,   53,   74,   53,   53,   53,   59,   53,
 597        53,   53,   53,   53,   53,   53,   53,   75,   75,   75,
 598        75,   53,   53,   53,   75,   75,   75,   75,   75,   75,
 599        75,   75,   75,   75,   75,   75,   75,   75,   53,   53,
 600        33,  119,  138,  108,  126,  232,  102,   76,  120,  138,
 601        77,   34,  143,  232,  123,  109,  152,  127,   78,  141,
 602       141,  141,  141,  153,  153,  145,  121,  160,   79,  144,
 603
 604       107,  119,  143,  155,  107,  161,  161,  160,  120,  124,
 605        80,   33,  144,  161,  169,  161,  105,  102,   76,  144,
 606       105,   77,   34,  229,  169,  229,  121,  169,  155,   78,
 607       141,  141,  141,  141,  169,  171,  145,  226,  226,   79,
 608       183,  107,  172,  172,  155,  107,  223,  184,  184,  106,
 609       223,   80,  146,  144,  107,  155,  220,  107,  107,  220,
 610       155,  107,  217,  217,  155,  214,  214,  155,  211,  144,
 611       211,  194,  155,  147,  147,  147,  147,  208,  208,  206,
 612       147,  147,  147,  147,  147,  147,  147,  147,  147,  147,
 613       147,  147,  147,  147,  105,  143,  105,  105,  105,  105,
 614
 615       105,  105,  105,  200,  105,  105,  105,  105,  168,  168,
 616       168,  168,  144,  105,  105,  105,  168,  168,  168,  168,
 617       105,  105,  105,  168,  168,  168,  168,  168,  168,  168,
 618       168,  168,  168,  168,  168,  168,  168,  105,  105,   32,
 619        32,   32,   32,   32,   32,   32,   32,   32,   32,   36,
 620        36,   36,   36,   36,   36,   36,   36,   36,   36,   81,
 621        81,   81,   81,   81,   81,   81,   81,   81,   81,   85,
 622        85,   85,   85,   85,   85,   85,   85,   85,   85,   88,
 623        88,   88,   88,   88,   88,   88,   88,   88,   88,   96,
 624        96,  205,   96,   96,   96,   96,   96,   96,   96,   97,
 625
 626       155,   97,  203,  203,   97,   97,   97,   97,  100,  201,
 627       200,  199,  155,  197,  197,  100,  101,  195,  101,  105,
 628       105,  105,  105,  194,  105,  105,  193,  105,  105,  111,
 629       155,  111,  112,  112,  112,  112,  112,  112,  112,  112,
 630       112,  112,  114,  114,  183,  114,  114,  114,  114,  114,
 631       114,  114,  122,  191,  122,  130,  130,  191,  130,  130,
 632       189,  130,  130,  130,  130,  133,  133,  188,  133,  133,
 633       133,  133,  133,  133,  133,  139,  187,  139,  186,  155,
 634       139,  139,  139,  139,  142,  182,  181,  181,  179,  142,
 635       178,  142,  151,  151,  177,  151,  151,  151,  151,  151,
 636
 637       151,  151,  154,  176,  154,  154,  175,  154,  154,  154,
 638       154,  156,  156,  156,  156,  156,  156,  156,  156,  156,
 639       156,  165,  174,  165,  157,  155,  165,  165,  165,  165,
 640       173,  170,  173,  173,  170,  173,  173,  173,  173,  180,
 641       167,  180,  166,  166,  180,  180,  180,  180,  185,  164,
 642       185,  185,  163,  185,  185,  185,  185,  190,  162,  190,
 643       159,  158,  190,  190,  190,  190,  192,  157,  192,  192,
 644       116,  192,  192,  192,  192,  196,  155,  196,  117,  150,
 645       196,  196,  196,  196,  198,  113,  198,  198,  103,  198,
 646       198,  198,  198,  202,  102,  202,   99,  140,  202,  202,
 647
 648       202,  202,  204,  140,  204,  204,  131,  204,  204,  204,
 649       204,  207,  129,  207,  128,  125,  207,  207,  207,  207,
 650       209,  117,  209,  209,  116,  209,  209,  209,  209,  210,
 651       115,  210,  113,  110,  210,  210,  210,  210,  212,  103,
 652       212,  212,  102,  212,  212,  212,  212,  213,   99,  213,
 653        98,   95,  213,  213,  213,  213,  215,  236,  215,  215,
 654        48,  215,  215,  215,  215,  216,   48,  216,  236,  236,
 655       216,  216,  216,  216,  218,  236,  218,  218,  236,  218,
 656       218,  218,  218,  219,  236,  219,  236,  236,  219,  219,
 657       219,  219,  221,  236,  221,  221,  236,  221,  221,  221,
 658
 659       221,  222,  236,  222,  236,  236,  222,  222,  222,  222,
 660       224,  236,  224,  224,  236,  224,  224,  224,  224,  225,
 661       236,  225,  236,  236,  225,  225,  225,  225,  227,  236,
 662       227,  227,  236,  227,  227,  227,  227,  228,  236,  228,
 663       236,  236,  228,  228,  228,  228,  230,  236,  230,  230,
 664       236,  230,  230,  230,  230,  231,  236,  231,  236,  236,
 665       231,  231,  231,  231,  233,  236,  233,  233,  236,  233,
 666       233,  233,  233,  235,  236,  235,  235,  236,  235,  235,
 667       235,  235,   31,  236,  236,  236,  236,  236,  236,  236,
 668       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
 669
 670       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
 671       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
 672       236,  236,  236,  236,  236,  236,  236,  236
 673     } ;
 674
 675 static yyconst flex_int16_t yy_chk[929] =
 676     {   0,
 677         0,    0,    1,    2,    3,    4,    0,    5,   27,    5,
 678         3,    4,   57,    1,    2,    3,    4,    5,    5,   27,
 679         7,    3,    4,    6,   57,    6,    5,    7,    8,   25,
 680        26,    7,    5,    6,    6,    8,   28,   25,   26,    8,
 681        25,   26,    6,   34,   40,   40,   34,   28,    6,    9,
 682         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 683         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 684         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 685         9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 686         9,    9,    9,    9,   13,   13,  246,   14,   14,   15,
 687
 688        15,   16,   16,   29,   29,   13,   39,   13,   14,   39,
 689        14,   30,   30,   46,   59,   29,   46,   59,   73,   56,
 690        60,   60,   29,   30,   56,  235,   73,   89,   56,   84,
 691        30,   89,   84,  233,   15,   15,   16,   16,   17,   17,
 692        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
 693        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
 694        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
 695        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
 696        17,   17,   17,   19,   69,   19,   78,   76,   19,   19,
 697        19,   62,   19,   19,   19,   70,   69,  232,   87,   78,
 698
 699        19,   87,   19,   62,   19,   19,   19,   70,   92,   94,
 700        62,   62,   76,   91,   70,   70,   91,  109,  231,   94,
 701       109,   92,   19,  230,   19,   21,   21,   21,   21,   21,
 702        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
 703        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
 704        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
 705        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
 706        23,   74,   93,  108,  126,  229,  100,   23,   74,   93,
 707        23,   23,  105,  228,  123,  108,  115,  126,   23,  100,
 708       100,  100,  100,  115,  115,  106,   74,  132,   23,  105,
 709
 710       106,  119,  143,  227,  106,  135,  134,  132,  119,  123,
 711        23,   24,  106,  134,  149,  135,  146,  141,   24,  143,
 712       146,   24,   24,  226,  149,  225,  119,  148,  224,   24,
 713       141,  141,  141,  141,  148,  153,  145,  223,  222,   24,
 714       172,  145,  153,  153,  221,  145,  220,  172,  172,  167,
 715       219,   24,  107,  145,  167,  218,  217,  107,  167,  216,
 716       215,  107,  214,  213,  212,  211,  210,  209,  208,  107,
 717       207,  206,  204,  107,  107,  107,  107,  203,  202,  201,
 718       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
 719       107,  107,  107,  107,  147,  147,  147,  147,  147,  147,
 720
 721       147,  147,  147,  200,  147,  147,  147,  147,  147,  147,
 722       147,  147,  147,  147,  147,  147,  147,  147,  147,  147,
 723       147,  147,  147,  147,  147,  147,  147,  147,  147,  147,
 724       147,  147,  147,  147,  147,  147,  147,  147,  147,  237,
 725       237,  237,  237,  237,  237,  237,  237,  237,  237,  238,
 726       238,  238,  238,  238,  238,  238,  238,  238,  238,  239,
 727       239,  239,  239,  239,  239,  239,  239,  239,  239,  240,
 728       240,  240,  240,  240,  240,  240,  240,  240,  240,  241,
 729       241,  241,  241,  241,  241,  241,  241,  241,  241,  242,
 730       242,  199,  242,  242,  242,  242,  242,  242,  242,  243,
 731
 732       198,  243,  197,  196,  243,  243,  243,  243,  244,  195,
 733       194,  193,  192,  191,  190,  244,  245,  189,  245,  247,
 734       247,  247,  247,  188,  247,  247,  187,  247,  247,  248,
 735       185,  248,  249,  249,  249,  249,  249,  249,  249,  249,
 736       249,  249,  250,  250,  184,  250,  250,  250,  250,  250,
 737       250,  250,  251,  181,  251,  252,  252,  180,  252,  252,
 738       179,  252,  252,  252,  252,  253,  253,  178,  253,  253,
 739       253,  253,  253,  253,  253,  254,  175,  254,  174,  173,
 740       254,  254,  254,  254,  255,  169,  166,  165,  163,  255,
 741       162,  255,  256,  256,  161,  256,  256,  256,  256,  256,
 742
 743       256,  256,  257,  160,  257,  257,  159,  257,  257,  257,
 744       257,  258,  258,  258,  258,  258,  258,  258,  258,  258,
 745       258,  259,  158,  259,  156,  154,  259,  259,  259,  259,
 746       260,  152,  260,  260,  151,  260,  260,  260,  260,  261,
 747       144,  261,  140,  139,  261,  261,  261,  261,  262,  138,
 748       262,  262,  137,  262,  262,  262,  262,  263,  136,  263,
 749       129,  128,  263,  263,  263,  263,  264,  124,  264,  264,
 750       118,  264,  264,  264,  264,  265,  117,  265,  116,  114,
 751       265,  265,  265,  265,  266,  112,  266,  266,  103,  266,
 752       266,  266,  266,  267,  102,  267,   99,   98,  267,  267,
 753
 754       267,  267,  268,   97,  268,  268,   83,  268,  268,  268,
 755       268,  269,   80,  269,   79,   77,  269,  269,  269,  269,
 756       270,   72,  270,  270,   71,  270,  270,  270,  270,  271,
 757        67,  271,   64,   58,  271,  271,  271,  271,  272,   54,
 758       272,  272,   48,  272,  272,  272,  272,  273,   45,  273,
 759        42,   38,  273,  273,  273,  273,  274,   31,  274,  274,
 760        12,  274,  274,  274,  274,  275,   11,  275,    0,    0,
 761       275,  275,  275,  275,  276,    0,  276,  276,    0,  276,
 762       276,  276,  276,  277,    0,  277,    0,    0,  277,  277,
 763       277,  277,  278,    0,  278,  278,    0,  278,  278,  278,
 764
 765       278,  279,    0,  279,    0,    0,  279,  279,  279,  279,
 766       280,    0,  280,  280,    0,  280,  280,  280,  280,  281,
 767         0,  281,    0,    0,  281,  281,  281,  281,  282,    0,
 768       282,  282,    0,  282,  282,  282,  282,  283,    0,  283,
 769         0,    0,  283,  283,  283,  283,  284,    0,  284,  284,
 770         0,  284,  284,  284,  284,  285,    0,  285,    0,    0,
 771       285,  285,  285,  285,  286,    0,  286,  286,    0,  286,
 772       286,  286,  286,  287,    0,  287,  287,    0,  287,  287,
 773       287,  287,  236,  236,  236,  236,  236,  236,  236,  236,
 774       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
 775
 776       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
 777       236,  236,  236,  236,  236,  236,  236,  236,  236,  236,
 778       236,  236,  236,  236,  236,  236,  236,  236
 779     } ;
 780
 781 extern int defargsYY_flex_debug;
 782 int defargsYY_flex_debug = 0;
 783
 784 static yy_state_type *yy_state_buf=0, *yy_state_ptr=0;
 785 static char *yy_full_match;
 786 static int yy_lp;
 787 static int yy_looking_for_trail_begin = 0;
 788 static int yy_full_lp;
 789 static int *yy_full_state;
 790 #define YY_TRAILING_MASK 0x2000
 791 #define YY_TRAILING_HEAD_MASK 0x4000
 792 #define REJECT \
 793 { \
 794 *yy_cp = (yy_hold_char); /* undo effects of setting up defargsYYtext */ \
 795 yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
 796 (yy_lp) = (yy_full_lp); /* restore orig. accepting pos. */ \
 797 (yy_state_ptr) = (yy_full_state); /* restore orig. state */ \
 798 yy_current_state = *(yy_state_ptr); /* restore curr. state */ \
 799 ++(yy_lp); \
 800 goto find_rule; \
 801 }
 802
 803 #define yymore() yymore_used_but_not_detected
 804 #define YY_MORE_ADJ 0
 805 #define YY_RESTORE_YY_MORE_OFFSET
 806 char *defargsYYtext;
 807 #line 1 "defargs.l"
 808 /******************************************************************************
 809  *
 810  *
 811  *
 812  * Copyright (C) 1997-2012 by Dimitri van Heesch.
 813  *
 814  * Permission to use, copy, modify, and distribute this software and its
 815  * documentation under the terms of the GNU General Public License is hereby
 816  * granted. No representations are made about the suitability of this software
 817  * for any purpose. It is provided "as is" without express or implied warranty.
 818  * See the GNU General Public License for more details.
 819  *
 820  * Documents produced by Doxygen are derivative works derived from the
 821  * input used in their production; they are not affected by this license.
 822  *
 823  */
 824 /*! \file
 825  *  This scanner is used to convert a string into a list of function or
 826  *  template arguments. Each parsed argument results in a Argument struct,
 827  *  that is put into an ArgumentList in declaration order.
 828  *  Comment blocks for arguments can also be included in the string.
 829  *  The argument string does not contain new-lines (except inside any
 830  *  comment blocks).
 831  *  An Argument consists of the string fields:
 832  *                 type,name,default value, and documentation
 833  *  The Argument list as a whole can be pure, constant or volatile.
 834  *
 835  *  Examples of input strings are:
 836  *  \code
 837  *    "(int a,int b) const"
 838  *    "(const char *s="hello world",int=5) = 0"
 839  *    "<class T,class N>"
 840  *    "(char c,const char)"
 841  *  \endcode
 842  *
 843  *  Note: It is not always possible to distinguish between the name and
 844  *        type of an argument. In case of doubt the name is added to the
 845  *        type, and the matchArgumentList in util.cpp is be used to
 846  *        further determine the correct separation.
 847  */
 848 #line 44 "defargs.l"
 849
 850 /*
 851  *      includes
 852  */
 853 #include "qtbc.h"
 854 #include <stdio.h>
 855 //#include <iostream.h>
 856 #include <assert.h>
 857 #include <ctype.h>
 858 #include <qregexp.h>
 859
 860 #include "defargs.h"
 861 #include "entry.h"
 862 #include "util.h"
 863 #include "arguments.h"
 864
 865 #define YY_NEVER_INTERACTIVE 1
 866 #define YY_NO_INPUT 1
 867
 868 /* -----------------------------------------------------------------
 869  *      state variables
 870  */
 871 static const char      *g_inputString;
 872 static int              g_inputPosition;
 873 static ArgumentList    *g_argList;
 874 static QCString        *g_copyArgValue;
 875 static QCString         g_curArgTypeName;
 876 static QCString         g_curArgDefValue;
 877 static QCString         g_curArgName;
 878 static QCString         g_curArgDocs;
 879 static QCString         g_curArgAttrib;
 880 static QCString         g_curArgArray;
 881 static QCString         g_extraTypeChars;
 882 static int              g_argRoundCount;
 883 static int              g_argSharpCount;
 884 static int              g_argCurlyCount;
 885 static int              g_readArgContext;
 886 static int              g_lastDocContext;
 887 static int              g_lastDocChar;
 888 static QCString         g_delimiter;
 889
 890 /* -----------------------------------------------------------------
 891  */
 892 #undef  YY_INPUT
 893 #define YY_INPUT(buf,result,max_size) result=yyread(buf,max_size);
 894
 895 static int yyread(char *buf,int max_size)
 896 {
 897     int c=0;
 898     while( c < max_size && g_inputString[g_inputPosition] )
 899     {
 900         *buf = g_inputString[g_inputPosition++] ;
 901         c++; buf++;
 902     }
 903     return c;
 904 }
 905
 906
 907
 908
 909
 910
 911
 912
 913
 914
 915
 916
 917
 918
 919
 920 #line 921 "<stdout>"
 921
 922 #define INITIAL 0
 923 #define Start 1
 924 #define CopyArgString 2
 925 #define CopyRawString 3
 926 #define CopyArgRound 4
 927 #define CopyArgRound2 5
 928 #define CopyArgSharp 6
 929 #define CopyArgCurly 7
 930 #define ReadFuncArgType 8
 931 #define ReadFuncArgDef 9
 932 #define ReadFuncArgPtr 10
 933 #define FuncQual 11
 934 #define ReadDocBlock 12
 935 #define ReadDocLine 13
 936 #define TrailingReturn 14
 937
 938 #ifndef YY_NO_UNISTD_H
 939 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 940  * down here because we want the user's section 1 to have been scanned first.
 941  * The user has a chance to override it with an option.
 942  */
 943 #include <unistd.h>
 944 #endif
 945
 946 #ifndef YY_EXTRA_TYPE
 947 #define YY_EXTRA_TYPE void *
 948 #endif
 949
 950 static int yy_init_globals (void );
 951
 952 /* Accessor methods to globals.
 953    These are made visible to non-reentrant scanners for convenience. */
 954
 955 int defargsYYlex_destroy (void );
 956
 957 int defargsYYget_debug (void );
 958
 959 void defargsYYset_debug (int debug_flag  );
 960
 961 YY_EXTRA_TYPE defargsYYget_extra (void );
 962
 963 void defargsYYset_extra (YY_EXTRA_TYPE user_defined  );
 964
 965 FILE *defargsYYget_in (void );
 966
 967 void defargsYYset_in  (FILE * in_str  );
 968
 969 FILE *defargsYYget_out (void );
 970
 971 void defargsYYset_out  (FILE * out_str  );
 972
 973 yy_size_t defargsYYget_leng (void );
 974
 975 char *defargsYYget_text (void );
 976
 977 int defargsYYget_lineno (void );
 978
 979 void defargsYYset_lineno (int line_number  );
 980
 981 /* Macros after this point can all be overridden by user definitions in
 982  * section 1.
 983  */
 984
 985 #ifndef YY_SKIP_YYWRAP
 986 #ifdef __cplusplus
 987 extern "C" int defargsYYwrap (void );
 988 #else
 989 extern int defargsYYwrap (void );
 990 #endif
 991 #endif
 992
 993     static void yyunput (int c,char *buf_ptr  );
 994
 995 #ifndef yytext_ptr
 996 static void yy_flex_strncpy (char *,yyconst char *,int );
 997 #endif
 998
 999 #ifdef YY_NEED_STRLEN
1000 static int yy_flex_strlen (yyconst char * );
1001 #endif
1002
1003 #ifndef YY_NO_INPUT
1004
1005 #ifdef __cplusplus
1006 static int yyinput (void );
1007 #else
1008 static int input (void );
1009 #endif
1010
1011 #endif
1012
1013 /* Amount of stuff to slurp up with each read. */
1014 #ifndef YY_READ_BUF_SIZE
1015 #define YY_READ_BUF_SIZE 262144
1016 #endif
1017
1018 /* Copy whatever the last rule matched to the standard output. */
1019 #ifndef ECHO
1020 /* This used to be an fputs(), but since the string might contain NUL's,
1021  * we now use fwrite().
1022  */
1023 #define ECHO fwrite( defargsYYtext, defargsYYleng, 1, defargsYYout )
1024 #endif
1025
1026 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1027  * is returned in "result".
1028  */
1029 #ifndef YY_INPUT
1030 #define YY_INPUT(buf,result,max_size) \
1031         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1032                 { \
1033                 int c = '*'; \
1034                 yy_size_t n; \
1035                 for ( n = 0; n < max_size && \
1036                              (c = getc( defargsYYin )) != EOF && c != '\n'; ++n ) \
1037                         buf[n] = (char) c; \
1038                 if ( c == '\n' ) \
1039                         buf[n++] = (char) c; \
1040                 if ( c == EOF && ferror( defargsYYin ) ) \
1041                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1042                 result = n; \
1043                 } \
1044         else \
1045                 { \
1046                 errno=0; \
1047                 while ( (result = fread(buf, 1, max_size, defargsYYin))==0 && ferror(defargsYYin)) \
1048                         { \
1049                         if( errno != EINTR) \
1050                                 { \
1051                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1052                                 break; \
1053                                 } \
1054                         errno=0; \
1055                         clearerr(defargsYYin); \
1056                         } \
1057                 }\
1058 \
1059
1060 #endif
1061
1062 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1063  * we don't want an extra ';' after the "return" because that will cause
1064  * some compilers to complain about unreachable statements.
1065  */
1066 #ifndef yyterminate
1067 #define yyterminate() return YY_NULL
1068 #endif
1069
1070 /* Number of entries by which start-condition stack grows. */
1071 #ifndef YY_START_STACK_INCR
1072 #define YY_START_STACK_INCR 25
1073 #endif
1074
1075 /* Report a fatal error. */
1076 #ifndef YY_FATAL_ERROR
1077 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1078 #endif
1079
1080 /* end tables serialization structures and prototypes */
1081
1082 /* Default declaration of generated scanner - a define so the user can
1083  * easily add parameters.
1084  */
1085 #ifndef YY_DECL
1086 #define YY_DECL_IS_OURS 1
1087
1088 extern int defargsYYlex (void);
1089
1090 #define YY_DECL int defargsYYlex (void)
1091 #endif /* !YY_DECL */
1092
1093 /* Code executed at the beginning of each rule, after defargsYYtext and defargsYYleng
1094  * have been set up.
1095  */
1096 #ifndef YY_USER_ACTION
1097 #define YY_USER_ACTION
1098 #endif
1099
1100 /* Code executed at the end of each rule. */
1101 #ifndef YY_BREAK
1102 #define YY_BREAK break;
1103 #endif
1104
1105 #define YY_RULE_SETUP \
1106         YY_USER_ACTION
1107
1108 /** The main scanner function which does all the work.
1109  */
1110 YY_DECL
1111 {
1112         register yy_state_type yy_current_state;
1113         register char *yy_cp, *yy_bp;
1114         register int yy_act;
1115
1116 #line 126 "defargs.l"
1117
1118
1119 #line 1120 "<stdout>"
1120
1121         if ( !(yy_init) )
1122                 {
1123                 (yy_init) = 1;
1124
1125 #ifdef YY_USER_INIT
1126                 YY_USER_INIT;
1127 #endif
1128
1129         /* Create the reject buffer large enough to save one state per allowed character. */
1130         if ( ! (yy_state_buf) )
1131             (yy_state_buf) = (yy_state_type *)defargsYYalloc(YY_STATE_BUF_SIZE  );
1132             if ( ! (yy_state_buf) )
1133                 YY_FATAL_ERROR( "out of dynamic memory in defargsYYlex()" );
1134
1135                 if ( ! (yy_start) )
1136                         (yy_start) = 1; /* first start state */
1137
1138                 if ( ! defargsYYin )
1139                         defargsYYin = stdin;
1140
1141                 if ( ! defargsYYout )
1142                         defargsYYout = stdout;
1143
1144                 if ( ! YY_CURRENT_BUFFER ) {
1145                         defargsYYensure_buffer_stack ();
1146                         YY_CURRENT_BUFFER_LVALUE =
1147                                 defargsYY_create_buffer(defargsYYin,YY_BUF_SIZE );
1148                 }
1149
1150                 defargsYY_load_buffer_state( );
1151                 }
1152
1153         while ( 1 )             /* loops until end-of-file is reached */
1154                 {
1155                 yy_cp = (yy_c_buf_p);
1156
1157                 /* Support of defargsYYtext. */
1158                 *yy_cp = (yy_hold_char);
1159
1160                 /* yy_bp points to the position in yy_ch_buf of the start of
1161                  * the current run.
1162                  */
1163                 yy_bp = yy_cp;
1164
1165                 yy_current_state = (yy_start);
1166
1167                 (yy_state_ptr) = (yy_state_buf);
1168                 *(yy_state_ptr)++ = yy_current_state;
1169
1170 yy_match:
1171                 do
1172                         {
1173                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1174                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1175                                 {
1176                                 yy_current_state = (int) yy_def[yy_current_state];
1177                                 if ( yy_current_state >= 237 )
1178                                         yy_c = yy_meta[(unsigned int) yy_c];
1179                                 }
1180                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1181                         *(yy_state_ptr)++ = yy_current_state;
1182                         ++yy_cp;
1183                         }
1184                 while ( yy_base[yy_current_state] != 883 );
1185
1186 yy_find_action:
1187                 yy_current_state = *--(yy_state_ptr);
1188                 (yy_lp) = yy_accept[yy_current_state];
1189 goto find_rule; /* Shut up GCC warning -Wall */
1190 find_rule: /* we branch to this label when backing up */
1191                 for ( ; ; ) /* until we find what rule we matched */
1192                         {
1193                         if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
1194                                 {
1195                                 yy_act = yy_acclist[(yy_lp)];
1196                                 if ( yy_act & YY_TRAILING_HEAD_MASK ||
1197                                      (yy_looking_for_trail_begin) )
1198                                         {
1199                                         if ( yy_act == (yy_looking_for_trail_begin) )
1200                                                 {
1201                                                 (yy_looking_for_trail_begin) = 0;
1202                                                 yy_act &= ~YY_TRAILING_HEAD_MASK;
1203                                                 break;
1204                                                 }
1205                                         }
1206                                 else if ( yy_act & YY_TRAILING_MASK )
1207                                         {
1208                                         (yy_looking_for_trail_begin) = yy_act & ~YY_TRAILING_MASK;
1209                                         (yy_looking_for_trail_begin) |= YY_TRAILING_HEAD_MASK;
1210                                         }
1211                                 else
1212                                         {
1213                                         (yy_full_match) = yy_cp;
1214                                         (yy_full_state) = (yy_state_ptr);
1215                                         (yy_full_lp) = (yy_lp);
1216                                         break;
1217                                         }
1218                                 ++(yy_lp);
1219                                 goto find_rule;
1220                                 }
1221                         --yy_cp;
1222                         yy_current_state = *--(yy_state_ptr);
1223                         (yy_lp) = yy_accept[yy_current_state];
1224                         }
1225
1226                 YY_DO_BEFORE_ACTION;
1227
1228 do_action:      /* This label is used only to access EOF actions. */
1229
1230                 switch ( yy_act )
1231         { /* beginning of action switch */
1232 case 1:
1233 YY_RULE_SETUP
1234 #line 128 "defargs.l"
1235 { BEGIN(ReadFuncArgType); }
1236         YY_BREAK
1237 case 2:
1238 YY_RULE_SETUP
1239 #line 130 "defargs.l"
1240 {
1241                                           g_curArgTypeName+=" ";
1242                                         }
1243         YY_BREAK
1244 case 3:
1245 /* rule 3 can match eol */
1246 YY_RULE_SETUP
1247 #line 133 "defargs.l"
1248 {
1249                                           if (g_curArgTypeName.stripWhiteSpace().isEmpty())
1250                                           {
1251                                             g_curArgAttrib=defargsYYtext; // for M$-IDL
1252                                           }
1253                                           else // array type
1254                                           {
1255                                             g_curArgArray+=defargsYYtext;
1256                                           }
1257                                         }
1258         YY_BREAK
1259 case 4:
1260 YY_RULE_SETUP
1261 #line 143 "defargs.l"
1262 { g_curArgDefValue+=defargsYYtext; }
1263         YY_BREAK
1264 case 5:
1265 YY_RULE_SETUP
1266 #line 144 "defargs.l"
1267 { g_curArgDefValue+=defargsYYtext; }
1268         YY_BREAK
1269 case 6:
1270 YY_RULE_SETUP
1271 #line 145 "defargs.l"
1272 { g_curArgDefValue+=defargsYYtext; }
1273         YY_BREAK
1274 case 7:
1275 /* rule 7 can match eol */
1276 YY_RULE_SETUP
1277 #line 146 "defargs.l"
1278 { g_curArgDefValue+=defargsYYtext;
1279                                           QCString text=defargsYYtext;
1280                                           int i=text.find('"');
1281                                           g_delimiter = defargsYYtext+i+1;
1282                                           g_delimiter=g_delimiter.left(g_delimiter.length()-1);
1283                                           BEGIN( CopyRawString );
1284                                         }
1285         YY_BREAK
1286 case 8:
1287 YY_RULE_SETUP
1288 #line 153 "defargs.l"
1289 {
1290                                           g_curArgDefValue+=*defargsYYtext;
1291                                           BEGIN( CopyArgString );
1292                                         }
1293         YY_BREAK
1294 case 9:
1295 /* rule 9 can match eol */
1296 YY_RULE_SETUP
1297 #line 157 "defargs.l"
1298 {
1299                                           // function pointer as argument
1300                                           g_curArgTypeName+=defargsYYtext;
1301                                           //g_curArgTypeName=g_curArgTypeName.simplifyWhiteSpace();
1302                                           BEGIN( ReadFuncArgPtr );
1303                                         }
1304         YY_BREAK
1305 case 10:
1306 YY_RULE_SETUP
1307 #line 163 "defargs.l"
1308 {
1309                                           g_curArgName=defargsYYtext;
1310                                         }
1311         YY_BREAK
1312 case 11:
1313 YY_RULE_SETUP
1314 #line 166 "defargs.l"
1315 { // function pointer
1316                                           g_curArgTypeName+=defargsYYtext;
1317                                           //g_curArgTypeName=g_curArgTypeName.simplifyWhiteSpace();
1318                                           g_readArgContext = ReadFuncArgType;
1319                                           g_copyArgValue=&g_curArgTypeName;
1320                                           g_argRoundCount=0;
1321                                           BEGIN( CopyArgRound2 );
1322                                         }
1323         YY_BREAK
1324 case 12:
1325 *yy_cp = (yy_hold_char); /* undo effects of setting up defargsYYtext */
1326 (yy_c_buf_p) = yy_cp = yy_bp + 1;
1327 YY_DO_BEFORE_ACTION; /* set up defargsYYtext again */
1328 YY_RULE_SETUP
1329 #line 174 "defargs.l"
1330 { // pointer to fixed size array
1331                                           g_curArgTypeName+=defargsYYtext;
1332                                           g_curArgTypeName+=g_curArgName;
1333                                           //g_curArgTypeName=g_curArgTypeName.simplifyWhiteSpace();
1334                                           BEGIN( ReadFuncArgType );
1335                                         }
1336         YY_BREAK
1337 case 13:
1338 YY_RULE_SETUP
1339 #line 180 "defargs.l"
1340 { // redundant braces detected / remove them
1341                                           int i=g_curArgTypeName.findRev('('),l=g_curArgTypeName.length();
1342                                           if (i!=-1)
1343                                             g_curArgTypeName=g_curArgTypeName.left(i)+
1344                                                            g_curArgTypeName.right(l-i-1);
1345                                           g_curArgTypeName+=g_curArgName;
1346                                           BEGIN( ReadFuncArgType );
1347                                         }
1348         YY_BREAK
1349 case 14:
1350 YY_RULE_SETUP
1351 #line 188 "defargs.l"
1352 { // handle operators in defargs
1353                                           g_curArgTypeName+=defargsYYtext;
1354                                         }
1355         YY_BREAK
1356 case 15:
1357 YY_RULE_SETUP
1358 #line 191 "defargs.l"
1359 {
1360                                           if (YY_START==ReadFuncArgType)
1361                                           {
1362                                             g_curArgTypeName+=*defargsYYtext;
1363                                             g_copyArgValue=&g_curArgTypeName;
1364                                           }
1365                                           else // YY_START==ReadFuncArgDef
1366                                           {
1367                                             g_curArgDefValue+=*defargsYYtext;
1368                                             g_copyArgValue=&g_curArgDefValue;
1369                                           }
1370                                           g_readArgContext = YY_START;
1371                                           if (*defargsYYtext=='(')
1372                                           {
1373                                             g_argRoundCount=0;
1374                                             BEGIN( CopyArgRound );
1375                                           }
1376                                           else if (*defargsYYtext=='{')
1377                                           {
1378                                             g_argCurlyCount=0;
1379                                             BEGIN( CopyArgCurly );
1380                                           }
1381                                           else // defargsYYtext=='<'
1382                                           {
1383                                             g_argSharpCount=0;
1384                                             BEGIN( CopyArgSharp );
1385                                           }
1386                                         }
1387         YY_BREAK
1388 case 16:
1389 YY_RULE_SETUP
1390 #line 219 "defargs.l"
1391 {
1392                                           g_argRoundCount++;
1393                                           *g_copyArgValue += *defargsYYtext;
1394                                         }
1395         YY_BREAK
1396 case 17:
1397 YY_RULE_SETUP
1398 #line 223 "defargs.l"
1399 {
1400                                           *g_copyArgValue += defargsYYtext;
1401                                           if (g_argRoundCount>0)
1402                                           {
1403                                             g_argRoundCount--;
1404                                           }
1405                                           else
1406                                           {
1407                                             if (YY_START==CopyArgRound2)
1408                                             {
1409                                               *g_copyArgValue+=" "+g_curArgName;
1410                                             }
1411                                             BEGIN( g_readArgContext );
1412                                           }
1413                                         }
1414         YY_BREAK
1415 case 18:
1416 *yy_cp = (yy_hold_char); /* undo effects of setting up defargsYYtext */
1417 (yy_c_buf_p) = yy_cp = yy_bp + 1;
1418 YY_DO_BEFORE_ACTION; /* set up defargsYYtext again */
1419 YY_RULE_SETUP
1420 #line 238 "defargs.l"
1421 {
1422                                           *g_copyArgValue += *defargsYYtext;
1423                                           if (g_argRoundCount>0) g_argRoundCount--;
1424                                           else BEGIN( g_readArgContext );
1425                                         }
1426         YY_BREAK
1427 case 19:
1428 YY_RULE_SETUP
1429 #line 243 "defargs.l"
1430 {
1431                                           g_argSharpCount++;
1432                                           *g_copyArgValue += *defargsYYtext;
1433                                         }
1434         YY_BREAK
1435 case 20:
1436 YY_RULE_SETUP
1437 #line 247 "defargs.l"
1438 {
1439                                           *g_copyArgValue += *defargsYYtext;
1440                                           if (g_argSharpCount>0) g_argSharpCount--;
1441                                           else BEGIN( g_readArgContext );
1442                                         }
1443         YY_BREAK
1444 case 21:
1445 YY_RULE_SETUP
1446 #line 252 "defargs.l"
1447 {
1448                                           g_argCurlyCount++;
1449                                           *g_copyArgValue += *defargsYYtext;
1450                                         }
1451         YY_BREAK
1452 case 22:
1453 YY_RULE_SETUP
1454 #line 256 "defargs.l"
1455 {
1456                                           *g_copyArgValue += *defargsYYtext;
1457                                           if (g_argCurlyCount>0) g_argCurlyCount--;
1458                                           else BEGIN( g_readArgContext );
1459                                         }
1460         YY_BREAK
1461 case 23:
1462 YY_RULE_SETUP
1463 #line 261 "defargs.l"
1464 {
1465                                           g_curArgDefValue+=defargsYYtext;
1466                                         }
1467         YY_BREAK
1468 case 24:
1469 /* rule 24 can match eol */
1470 YY_RULE_SETUP
1471 #line 264 "defargs.l"
1472 {
1473                                           g_curArgDefValue+=defargsYYtext;
1474                                           QCString delimiter = defargsYYtext+1;
1475                                           delimiter=delimiter.left(delimiter.length()-1);
1476                                           if (delimiter==g_delimiter)
1477                                           {
1478                                             BEGIN( ReadFuncArgDef );
1479                                           }
1480                                         }
1481         YY_BREAK
1482 case 25:
1483 YY_RULE_SETUP
1484 #line 273 "defargs.l"
1485 {
1486                                           g_curArgDefValue+=*defargsYYtext;
1487                                           BEGIN( ReadFuncArgDef );
1488                                         }
1489         YY_BREAK
1490 case 26:
1491 YY_RULE_SETUP
1492 #line 277 "defargs.l"
1493 {
1494                                           BEGIN( ReadFuncArgDef );
1495                                         }
1496         YY_BREAK
1497 case 27:
1498 YY_RULE_SETUP
1499 #line 280 "defargs.l"
1500 {
1501                                           g_lastDocContext=YY_START;
1502                                           g_lastDocChar=*defargsYYtext;
1503                                           QCString text=defargsYYtext;
1504                                           if (text.find("//")!=-1)
1505                                             BEGIN( ReadDocLine );
1506                                           else
1507                                             BEGIN( ReadDocBlock );
1508                                         }
1509         YY_BREAK
1510 case 28:
1511 YY_RULE_SETUP
1512 #line 289 "defargs.l"
1513 {
1514                                           if (*defargsYYtext==')' && g_curArgTypeName.stripWhiteSpace().isEmpty())
1515                                           {
1516                                             g_curArgTypeName+=*defargsYYtext;
1517                                             BEGIN(FuncQual);
1518                                           }
1519                                           else
1520                                           {
1521                                             g_curArgTypeName=removeRedundantWhiteSpace(g_curArgTypeName);
1522                                             g_curArgDefValue=g_curArgDefValue.stripWhiteSpace();
1523                                             //printf("curArgType=`%s' curArgDefVal=`%s'\n",g_curArgTypeName.data(),g_curArgDefValue.data());
1524                                             int l=g_curArgTypeName.length();
1525                                             if (l>0)
1526                                             {
1527                                               int i=l-1;
1528                                               while (i>=0 && (isspace((uchar)g_curArgTypeName.at(i)) || g_curArgTypeName.at(i)=='.')) i--;
1529                                               while (i>=0 && (isId(g_curArgTypeName.at(i)) || g_curArgTypeName.at(i)=='$')) i--;
1530                                               Argument *a = new Argument;
1531                                               a->attrib = g_curArgAttrib.copy();
1532                                               //printf("a->type=%s a->name=%s i=%d l=%d\n",
1533                                               //        a->type.data(),a->name.data(),i,l);
1534                                               a->array.resize(0);
1535                                               if (i==l-1 && g_curArgTypeName.at(i)==')') // function argument
1536                                               {
1537                                                 int bi=g_curArgTypeName.find('(');
1538                                                 int fi=bi-1;
1539                                                 //printf("func arg fi=%d\n",fi);
1540                                                 while (fi>=0 && isId(g_curArgTypeName.at(fi))) fi--;
1541                                                 if (fi>=0)
1542                                                 {
1543                                                   a->type  = g_curArgTypeName.left(fi+1);
1544                                                   a->name  = g_curArgTypeName.mid(fi+1,bi-fi-1).stripWhiteSpace();
1545                                                   a->array = g_curArgTypeName.right(l-bi);
1546                                                 }
1547                                                 else
1548                                                 {
1549                                                   a->type = g_curArgTypeName;
1550                                                 }
1551                                               }
1552                                               else if (i>=0 && g_curArgTypeName.at(i)!=':')
1553                                               { // type contains a name
1554                                                 a->type = removeRedundantWhiteSpace(g_curArgTypeName.left(i+1)).stripWhiteSpace();
1555                                                 a->name = g_curArgTypeName.right(l-i-1).stripWhiteSpace();
1556
1557                                                 // if the type becomes a type specifier only then we make a mistake
1558                                                 // and need to correct it to avoid seeing a nameless parameter
1559                                                 // "struct A" as a parameter with type "struct" and name "A".
1560                                                 int sv=0;
1561                                                 if      (a->type.left(6)=="const ")    sv=6;
1562                                                 else if (a->type.left(9)=="volatile ") sv=9;
1563
1564                                                 if (a->type.mid(sv)=="struct"    ||
1565                                                     a->type.mid(sv)=="union"     ||
1566                                                     a->type.mid(sv)=="class"     ||
1567                                                     a->type.mid(sv)=="typename"  ||
1568                                                     a->type=="const"             ||
1569                                                     a->type=="volatile"
1570                                                    )
1571                                                 {
1572                                                   a->type = a->type + " " + a->name;
1573                                                   a->name.resize(0);
1574                                                 }
1575                                                 //printf(" --> a->type='%s'\n",a->type.data());
1576                                               }
1577                                               else // assume only the type was specified, try to determine name later
1578                                               {
1579                                                 a->type = removeRedundantWhiteSpace(g_curArgTypeName);
1580                                               }
1581                                               if (!a->type.isEmpty() && a->type.at(0)=='$') // typeless PHP name?
1582                                               {
1583                                                 a->name = a->type;
1584                                                 a->type = "";
1585                                               }
1586                                               a->array  += removeRedundantWhiteSpace(g_curArgArray);
1587                                               //printf("array=%s\n",a->array.data());
1588                                               int alen = a->array.length();
1589                                               if (alen>2 && a->array.at(0)=='(' &&
1590                                                             a->array.at(alen-1)==')') // fix-up for int *(a[10])
1591                                               {
1592                                                 int i=a->array.find('[')-1;
1593                                                 a->array = a->array.mid(1,alen-2);
1594                                                 if (i>0 && a->name.isEmpty())
1595                                                 {
1596                                                   a->name  = a->array.left(i).stripWhiteSpace();
1597                                                   a->array = a->array.mid(i);
1598                                                 }
1599                                               }
1600                                               a->defval = g_curArgDefValue.copy();
1601                                               //printf("a->type=%s a->name=%s a->defval=\"%s\"\n",a->type.data(),a->name.data(),a->defval.data());
1602                                               a->docs   = g_curArgDocs.stripWhiteSpace();
1603                                               //printf("Argument `%s' `%s' adding docs=`%s'\n",a->type.data(),a->name.data(),a->docs.data());
1604                                               g_argList->append(a);
1605                                             }
1606                                             g_curArgAttrib.resize(0);
1607                                             g_curArgTypeName.resize(0);
1608                                             g_curArgDefValue.resize(0);
1609                                             g_curArgArray.resize(0);
1610                                             g_curArgDocs.resize(0);
1611                                             if (*defargsYYtext==')')
1612                                             {
1613                                               BEGIN(FuncQual);
1614                                               //printf(">>> end of argument list\n");
1615                                             }
1616                                             else
1617                                             {
1618                                               BEGIN( ReadFuncArgType );
1619                                             }
1620                                           }
1621                                         }
1622         YY_BREAK
1623 case 29:
1624 YY_RULE_SETUP
1625 #line 398 "defargs.l"
1626 {
1627                                           QCString name=defargsYYtext; //resolveDefines(defargsYYtext);
1628                                           if (YY_START==ReadFuncArgType && g_curArgArray=="[]") // Java style array
1629                                           {
1630                                             g_curArgTypeName+=" []";
1631                                             g_curArgArray.resize(0);
1632                                           }
1633                                           //printf("resolveName `%s'->`%s'\n",defargsYYtext,name.data());
1634                                           g_curArgTypeName+=name;
1635                                         }
1636         YY_BREAK
1637 case 30:
1638 YY_RULE_SETUP
1639 #line 408 "defargs.l"
1640 {
1641                                           g_curArgTypeName+=*defargsYYtext;
1642                                         }
1643         YY_BREAK
1644 case 31:
1645 YY_RULE_SETUP
1646 #line 412 "defargs.l"
1647 {
1648                                           g_curArgDefValue+=defargsYYtext;
1649                                         }
1650         YY_BREAK
1651 case 32:
1652 YY_RULE_SETUP
1653 #line 415 "defargs.l"
1654 {
1655                                           g_curArgDefValue+=*defargsYYtext;
1656                                         }
1657         YY_BREAK
1658 case 33:
1659 YY_RULE_SETUP
1660 #line 418 "defargs.l"
1661 {
1662                                           QCString name=defargsYYtext; //resolveDefines(defargsYYtext);
1663                                           *g_copyArgValue+=name;
1664                                         }
1665         YY_BREAK
1666 case 34:
1667 YY_RULE_SETUP
1668 #line 422 "defargs.l"
1669 {
1670                                           *g_copyArgValue += *defargsYYtext;
1671                                         }
1672         YY_BREAK
1673 case 35:
1674 YY_RULE_SETUP
1675 #line 425 "defargs.l"
1676 {
1677                                           g_argList->constSpecifier=TRUE;
1678                                         }
1679         YY_BREAK
1680 case 36:
1681 YY_RULE_SETUP
1682 #line 428 "defargs.l"
1683 {
1684                                           g_argList->volatileSpecifier=TRUE;
1685                                         }
1686         YY_BREAK
1687 case 37:
1688 YY_RULE_SETUP
1689 #line 431 "defargs.l"
1690 {
1691                                           g_argList->pureSpecifier=TRUE;
1692                                           BEGIN(FuncQual);
1693                                         }
1694         YY_BREAK
1695 case 38:
1696 YY_RULE_SETUP
1697 #line 435 "defargs.l"
1698 { // C++11 trailing return type
1699                                           g_argList->trailingReturnType=" -> ";
1700                                           BEGIN(TrailingReturn);
1701                                         }
1702         YY_BREAK
1703 case 39:
1704 *yy_cp = (yy_hold_char); /* undo effects of setting up defargsYYtext */
1705 (yy_c_buf_p) = yy_cp = yy_bp + 1;
1706 YY_DO_BEFORE_ACTION; /* set up defargsYYtext again */
1707 YY_RULE_SETUP
1708 #line 439 "defargs.l"
1709 {
1710                                           unput(*defargsYYtext);
1711                                           BEGIN(FuncQual);
1712                                         }
1713         YY_BREAK
1714 case 40:
1715 YY_RULE_SETUP
1716 #line 443 "defargs.l"
1717 {
1718                                           g_argList->trailingReturnType+=defargsYYtext;
1719                                         }
1720         YY_BREAK
1721 case 41:
1722 /* rule 41 can match eol */
1723 YY_RULE_SETUP
1724 #line 446 "defargs.l"
1725 {
1726                                           g_argList->trailingReturnType+=defargsYYtext;
1727                                         }
1728         YY_BREAK
1729 case 42:
1730 /* rule 42 can match eol */
1731 YY_RULE_SETUP
1732 #line 449 "defargs.l"
1733 { // for functions returning a pointer to an array,
1734                                           // i.e. ")[]" in "int (*f(int))[4]" with argsString="(int))[4]"
1735                                           g_extraTypeChars=defargsYYtext;
1736                                         }
1737         YY_BREAK
1738 case 43:
1739 YY_RULE_SETUP
1740 #line 453 "defargs.l"
1741 {
1742                                           g_curArgDocs+=defargsYYtext;
1743                                         }
1744         YY_BREAK
1745 case 44:
1746 YY_RULE_SETUP
1747 #line 456 "defargs.l"
1748 {
1749                                           g_curArgDocs+=defargsYYtext;
1750                                         }
1751         YY_BREAK
1752 case 45:
1753 YY_RULE_SETUP
1754 #line 459 "defargs.l"
1755 {
1756                                           if (g_lastDocChar!=0)
1757                                             unput(g_lastDocChar);
1758                                           BEGIN(g_lastDocContext);
1759                                         }
1760         YY_BREAK
1761 case 46:
1762 /* rule 46 can match eol */
1763 YY_RULE_SETUP
1764 #line 464 "defargs.l"
1765 {
1766                                           if (g_lastDocChar!=0)
1767                                             unput(g_lastDocChar);
1768                                           BEGIN(g_lastDocContext);
1769                                         }
1770         YY_BREAK
1771 case 47:
1772 /* rule 47 can match eol */
1773 YY_RULE_SETUP
1774 #line 469 "defargs.l"
1775 {
1776                                           g_curArgDocs+=*defargsYYtext;
1777                                         }
1778         YY_BREAK
1779 case 48:
1780 YY_RULE_SETUP
1781 #line 472 "defargs.l"
1782 {
1783                                           g_curArgDocs+=*defargsYYtext;
1784                                         }
1785         YY_BREAK
1786 case 49:
1787 YY_RULE_SETUP
1788 #line 475 "defargs.l"
1789 {
1790                                           g_lastDocContext=YY_START;
1791                                           g_lastDocChar=0;
1792                                           if (defargsYYtext[1]=='/')
1793                                             BEGIN( ReadDocLine );
1794                                           else
1795                                             BEGIN( ReadDocBlock );
1796                                         }
1797         YY_BREAK
1798 case 50:
1799 /* rule 50 can match eol */
1800 YY_RULE_SETUP
1801 #line 483 "defargs.l"
1802
1803         YY_BREAK
1804 case 51:
1805 YY_RULE_SETUP
1806 #line 484 "defargs.l"
1807
1808         YY_BREAK
1809 case 52:
1810 YY_RULE_SETUP
1811 #line 486 "defargs.l"
1812 ECHO;
1813         YY_BREAK
1814 #line 1815 "<stdout>"
1815                         case YY_STATE_EOF(INITIAL):
1816                         case YY_STATE_EOF(Start):
1817                         case YY_STATE_EOF(CopyArgString):
1818                         case YY_STATE_EOF(CopyRawString):
1819                         case YY_STATE_EOF(CopyArgRound):
1820                         case YY_STATE_EOF(CopyArgRound2):
1821                         case YY_STATE_EOF(CopyArgSharp):
1822                         case YY_STATE_EOF(CopyArgCurly):
1823                         case YY_STATE_EOF(ReadFuncArgType):
1824                         case YY_STATE_EOF(ReadFuncArgDef):
1825                         case YY_STATE_EOF(ReadFuncArgPtr):
1826                         case YY_STATE_EOF(FuncQual):
1827                         case YY_STATE_EOF(ReadDocBlock):
1828                         case YY_STATE_EOF(ReadDocLine):
1829                         case YY_STATE_EOF(TrailingReturn):
1830                                 yyterminate();
1831
1832         case YY_END_OF_BUFFER:
1833                 {
1834                 /* Amount of text matched not including the EOB char. */
1835                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1836
1837                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1838                 *yy_cp = (yy_hold_char);
1839                 YY_RESTORE_YY_MORE_OFFSET
1840
1841                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1842                         {
1843                         /* We're scanning a new file or input source.  It's
1844                          * possible that this happened because the user
1845                          * just pointed defargsYYin at a new source and called
1846                          * defargsYYlex().  If so, then we have to assure
1847                          * consistency between YY_CURRENT_BUFFER and our
1848                          * globals.  Here is the right place to do so, because
1849                          * this is the first action (other than possibly a
1850                          * back-up) that will match for the new input source.
1851                          */
1852                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1853                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = defargsYYin;
1854                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1855                         }
1856
1857                 /* Note that here we test for yy_c_buf_p "<=" to the position
1858                  * of the first EOB in the buffer, since yy_c_buf_p will
1859                  * already have been incremented past the NUL character
1860                  * (since all states make transitions on EOB to the
1861                  * end-of-buffer state).  Contrast this with the test
1862                  * in input().
1863                  */
1864                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1865                         { /* This was really a NUL. */
1866                         yy_state_type yy_next_state;
1867
1868                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1869
1870                         yy_current_state = yy_get_previous_state(  );
1871
1872                         /* Okay, we're now positioned to make the NUL
1873                          * transition.  We couldn't have
1874                          * yy_get_previous_state() go ahead and do it
1875                          * for us because it doesn't know how to deal
1876                          * with the possibility of jamming (and we don't
1877                          * want to build jamming into it because then it
1878                          * will run more slowly).
1879                          */
1880
1881                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1882
1883                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1884
1885                         if ( yy_next_state )
1886                                 {
1887                                 /* Consume the NUL. */
1888                                 yy_cp = ++(yy_c_buf_p);
1889                                 yy_current_state = yy_next_state;
1890                                 goto yy_match;
1891                                 }
1892
1893                         else
1894                                 {
1895                                 yy_cp = (yy_c_buf_p);
1896                                 goto yy_find_action;
1897                                 }
1898                         }
1899
1900                 else switch ( yy_get_next_buffer(  ) )
1901                         {
1902                         case EOB_ACT_END_OF_FILE:
1903                                 {
1904                                 (yy_did_buffer_switch_on_eof) = 0;
1905
1906                                 if ( defargsYYwrap( ) )
1907                                         {
1908                                         /* Note: because we've taken care in
1909                                          * yy_get_next_buffer() to have set up
1910                                          * defargsYYtext, we can now set up
1911                                          * yy_c_buf_p so that if some total
1912                                          * hoser (like flex itself) wants to
1913                                          * call the scanner after we return the
1914                                          * YY_NULL, it'll still work - another
1915                                          * YY_NULL will get returned.
1916                                          */
1917                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1918
1919                                         yy_act = YY_STATE_EOF(YY_START);
1920                                         goto do_action;
1921                                         }
1922
1923                                 else
1924                                         {
1925                                         if ( ! (yy_did_buffer_switch_on_eof) )
1926                                                 YY_NEW_FILE;
1927                                         }
1928                                 break;
1929                                 }
1930
1931                         case EOB_ACT_CONTINUE_SCAN:
1932                                 (yy_c_buf_p) =
1933                                         (yytext_ptr) + yy_amount_of_matched_text;
1934
1935                                 yy_current_state = yy_get_previous_state(  );
1936
1937                                 yy_cp = (yy_c_buf_p);
1938                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1939                                 goto yy_match;
1940
1941                         case EOB_ACT_LAST_MATCH:
1942                                 (yy_c_buf_p) =
1943                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1944
1945                                 yy_current_state = yy_get_previous_state(  );
1946
1947                                 yy_cp = (yy_c_buf_p);
1948                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1949                                 goto yy_find_action;
1950                         }
1951                 break;
1952                 }
1953
1954         default:
1955                 YY_FATAL_ERROR(
1956                         "fatal flex scanner internal error--no action found" );
1957         } /* end of action switch */
1958                 } /* end of scanning one token */
1959 } /* end of defargsYYlex */
1960
1961 /* yy_get_next_buffer - try to read in a new buffer
1962  *
1963  * Returns a code representing an action:
1964  *      EOB_ACT_LAST_MATCH -
1965  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1966  *      EOB_ACT_END_OF_FILE - end of file
1967  */
1968 static int yy_get_next_buffer (void)
1969 {
1970         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1971         register char *source = (yytext_ptr);
1972         register int number_to_move, i;
1973         int ret_val;
1974
1975         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1976                 YY_FATAL_ERROR(
1977                 "fatal flex scanner internal error--end of buffer missed" );
1978
1979         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1980                 { /* Don't try to fill the buffer, so this is an EOF. */
1981                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1982                         {
1983                         /* We matched a single character, the EOB, so
1984                          * treat this as a final EOF.
1985                          */
1986                         return EOB_ACT_END_OF_FILE;
1987                         }
1988
1989                 else
1990                         {
1991                         /* We matched some text prior to the EOB, first
1992                          * process it.
1993                          */
1994                         return EOB_ACT_LAST_MATCH;
1995                         }
1996                 }
1997
1998         /* Try to read more data. */
1999
2000         /* First move last chars to start of buffer. */
2001         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2002
2003         for ( i = 0; i < number_to_move; ++i )
2004                 *(dest++) = *(source++);
2005
2006         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2007                 /* don't do the read, it's not guaranteed to return an EOF,
2008                  * just force an EOF
2009                  */
2010                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2011
2012         else
2013                 {
2014                         yy_size_t num_to_read =
2015                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2016
2017                 while ( num_to_read <= 0 )
2018                         { /* Not enough room in the buffer - grow it. */
2019
2020                         YY_FATAL_ERROR(
2021 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2022
2023                         }
2024
2025                 if ( num_to_read > YY_READ_BUF_SIZE )
2026                         num_to_read = YY_READ_BUF_SIZE;
2027
2028                 /* Read in more data. */
2029                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2030                         (yy_n_chars), num_to_read );
2031
2032                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2033                 }
2034
2035         if ( (yy_n_chars) == 0 )
2036                 {
2037                 if ( number_to_move == YY_MORE_ADJ )
2038                         {
2039                         ret_val = EOB_ACT_END_OF_FILE;
2040                         defargsYYrestart(defargsYYin  );
2041                         }
2042
2043                 else
2044                         {
2045                         ret_val = EOB_ACT_LAST_MATCH;
2046                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2047                                 YY_BUFFER_EOF_PENDING;
2048                         }
2049                 }
2050
2051         else
2052                 ret_val = EOB_ACT_CONTINUE_SCAN;
2053
2054         if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
2055                 /* Extend the array by 50%, plus the number we really need. */
2056                 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2057                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) defargsYYrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
2058                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2059                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
2060         }
2061
2062         (yy_n_chars) += number_to_move;
2063         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2064         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2065
2066         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2067
2068         return ret_val;
2069 }
2070
2071 /* yy_get_previous_state - get the state just before the EOB char was reached */
2072
2073     static yy_state_type yy_get_previous_state (void)
2074 {
2075         register yy_state_type yy_current_state;
2076         register char *yy_cp;
2077
2078         yy_current_state = (yy_start);
2079
2080         (yy_state_ptr) = (yy_state_buf);
2081         *(yy_state_ptr)++ = yy_current_state;
2082
2083         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
2084                 {
2085                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2086                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2087                         {
2088                         yy_current_state = (int) yy_def[yy_current_state];
2089                         if ( yy_current_state >= 237 )
2090                                 yy_c = yy_meta[(unsigned int) yy_c];
2091                         }
2092                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2093                 *(yy_state_ptr)++ = yy_current_state;
2094                 }
2095
2096         return yy_current_state;
2097 }
2098
2099 /* yy_try_NUL_trans - try to make a transition on the NUL character
2100  *
2101  * synopsis
2102  *      next_state = yy_try_NUL_trans( current_state );
2103  */
2104     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
2105 {
2106         register int yy_is_jam;
2107
2108         register YY_CHAR yy_c = 1;
2109         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2110                 {
2111                 yy_current_state = (int) yy_def[yy_current_state];
2112                 if ( yy_current_state >= 237 )
2113                         yy_c = yy_meta[(unsigned int) yy_c];
2114                 }
2115         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2116         yy_is_jam = (yy_current_state == 236);
2117         if ( ! yy_is_jam )
2118                 *(yy_state_ptr)++ = yy_current_state;
2119
2120         return yy_is_jam ? 0 : yy_current_state;
2121 }
2122
2123     static void yyunput (int c, register char * yy_bp )
2124 {
2125         register char *yy_cp;
2126
2127     yy_cp = (yy_c_buf_p);
2128
2129         /* undo effects of setting up defargsYYtext */
2130         *yy_cp = (yy_hold_char);
2131
2132         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2133                 { /* need to shift things up to make room */
2134                 /* +2 for EOB chars. */
2135                 register yy_size_t number_to_move = (yy_n_chars) + 2;
2136                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2137                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2138                 register char *source =
2139                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2140
2141                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2142                         *--dest = *--source;
2143
2144                 yy_cp += (int) (dest - source);
2145                 yy_bp += (int) (dest - source);
2146                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2147                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2148
2149                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2150                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2151                 }
2152
2153         *--yy_cp = (char) c;
2154
2155         (yytext_ptr) = yy_bp;
2156         (yy_hold_char) = *yy_cp;
2157         (yy_c_buf_p) = yy_cp;
2158 }
2159
2160 #ifndef YY_NO_INPUT
2161 #ifdef __cplusplus
2162     static int yyinput (void)
2163 #else
2164     static int input  (void)
2165 #endif
2166
2167 {
2168         int c;
2169
2170         *(yy_c_buf_p) = (yy_hold_char);
2171
2172         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2173                 {
2174                 /* yy_c_buf_p now points to the character we want to return.
2175                  * If this occurs *before* the EOB characters, then it's a
2176                  * valid NUL; if not, then we've hit the end of the buffer.
2177                  */
2178                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2179                         /* This was really a NUL. */
2180                         *(yy_c_buf_p) = '\0';
2181
2182                 else
2183                         { /* need more input */
2184                         yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
2185                         ++(yy_c_buf_p);
2186
2187                         switch ( yy_get_next_buffer(  ) )
2188                                 {
2189                                 case EOB_ACT_LAST_MATCH:
2190                                         /* This happens because yy_g_n_b()
2191                                          * sees that we've accumulated a
2192                                          * token and flags that we need to
2193                                          * try matching the token before
2194                                          * proceeding.  But for input(),
2195                                          * there's no matching to consider.
2196                                          * So convert the EOB_ACT_LAST_MATCH
2197                                          * to EOB_ACT_END_OF_FILE.
2198                                          */
2199
2200                                         /* Reset buffer status. */
2201                                         defargsYYrestart(defargsYYin );
2202
2203                                         /*FALLTHROUGH*/
2204
2205                                 case EOB_ACT_END_OF_FILE:
2206                                         {
2207                                         if ( defargsYYwrap( ) )
2208                                                 return 0;
2209
2210                                         if ( ! (yy_did_buffer_switch_on_eof) )
2211                                                 YY_NEW_FILE;
2212 #ifdef __cplusplus
2213                                         return yyinput();
2214 #else
2215                                         return input();
2216 #endif
2217                                         }
2218
2219                                 case EOB_ACT_CONTINUE_SCAN:
2220                                         (yy_c_buf_p) = (yytext_ptr) + offset;
2221                                         break;
2222                                 }
2223                         }
2224                 }
2225
2226         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
2227         *(yy_c_buf_p) = '\0';   /* preserve defargsYYtext */
2228         (yy_hold_char) = *++(yy_c_buf_p);
2229
2230         return c;
2231 }
2232 #endif  /* ifndef YY_NO_INPUT */
2233
2234 /** Immediately switch to a different input stream.
2235  * @param input_file A readable stream.
2236  *
2237  * @note This function does not reset the start condition to @c INITIAL .
2238  */
2239     void defargsYYrestart  (FILE * input_file )
2240 {
2241
2242         if ( ! YY_CURRENT_BUFFER ){
2243         defargsYYensure_buffer_stack ();
2244                 YY_CURRENT_BUFFER_LVALUE =
2245             defargsYY_create_buffer(defargsYYin,YY_BUF_SIZE );
2246         }
2247
2248         defargsYY_init_buffer(YY_CURRENT_BUFFER,input_file );
2249         defargsYY_load_buffer_state( );
2250 }
2251
2252 /** Switch to a different input buffer.
2253  * @param new_buffer The new input buffer.
2254  *
2255  */
2256     void defargsYY_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
2257 {
2258
2259         /* TODO. We should be able to replace this entire function body
2260          * with
2261          *              defargsYYpop_buffer_state();
2262          *              defargsYYpush_buffer_state(new_buffer);
2263      */
2264         defargsYYensure_buffer_stack ();
2265         if ( YY_CURRENT_BUFFER == new_buffer )
2266                 return;
2267
2268         if ( YY_CURRENT_BUFFER )
2269                 {
2270                 /* Flush out information for old buffer. */
2271                 *(yy_c_buf_p) = (yy_hold_char);
2272                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2273                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2274                 }
2275
2276         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2277         defargsYY_load_buffer_state( );
2278
2279         /* We don't actually know whether we did this switch during
2280          * EOF (defargsYYwrap()) processing, but the only time this flag
2281          * is looked at is after defargsYYwrap() is called, so it's safe
2282          * to go ahead and always set it.
2283          */
2284         (yy_did_buffer_switch_on_eof) = 1;
2285 }
2286
2287 static void defargsYY_load_buffer_state  (void)
2288 {
2289         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2290         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2291         defargsYYin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2292         (yy_hold_char) = *(yy_c_buf_p);
2293 }
2294
2295 /** Allocate and initialize an input buffer state.
2296  * @param file A readable stream.
2297  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2298  *
2299  * @return the allocated buffer state.
2300  */
2301     YY_BUFFER_STATE defargsYY_create_buffer  (FILE * file, int  size )
2302 {
2303         YY_BUFFER_STATE b;
2304
2305         b = (YY_BUFFER_STATE) defargsYYalloc(sizeof( struct yy_buffer_state )  );
2306         if ( ! b )
2307                 YY_FATAL_ERROR( "out of dynamic memory in defargsYY_create_buffer()" );
2308
2309         b->yy_buf_size = size;
2310
2311         /* yy_ch_buf has to be 2 characters longer than the size given because
2312          * we need to put in 2 end-of-buffer characters.
2313          */
2314         b->yy_ch_buf = (char *) defargsYYalloc(b->yy_buf_size + 2  );
2315         if ( ! b->yy_ch_buf )
2316                 YY_FATAL_ERROR( "out of dynamic memory in defargsYY_create_buffer()" );
2317
2318         b->yy_is_our_buffer = 1;
2319
2320         defargsYY_init_buffer(b,file );
2321
2322         return b;
2323 }
2324
2325 /** Destroy the buffer.
2326  * @param b a buffer created with defargsYY_create_buffer()
2327  *
2328  */
2329     void defargsYY_delete_buffer (YY_BUFFER_STATE  b )
2330 {
2331
2332         if ( ! b )
2333                 return;
2334
2335         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2336                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2337
2338         if ( b->yy_is_our_buffer )
2339                 defargsYYfree((void *) b->yy_ch_buf  );
2340
2341         defargsYYfree((void *) b  );
2342 }
2343
2344 #ifndef __cplusplus
2345 extern int isatty (int );
2346 #endif /* __cplusplus */
2347
2348 /* Initializes or reinitializes a buffer.
2349  * This function is sometimes called more than once on the same buffer,
2350  * such as during a defargsYYrestart() or at EOF.
2351  */
2352     static void defargsYY_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
2353
2354 {
2355         int oerrno = errno;
2356
2357         defargsYY_flush_buffer(b );
2358
2359         b->yy_input_file = file;
2360         b->yy_fill_buffer = 1;
2361
2362     /* If b is the current buffer, then defargsYY_init_buffer was _probably_
2363      * called from defargsYYrestart() or through yy_get_next_buffer.
2364      * In that case, we don't want to reset the lineno or column.
2365      */
2366     if (b != YY_CURRENT_BUFFER){
2367         b->yy_bs_lineno = 1;
2368         b->yy_bs_column = 0;
2369     }
2370
2371         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2372
2373         errno = oerrno;
2374 }
2375
2376 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2377  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2378  *
2379  */
2380     void defargsYY_flush_buffer (YY_BUFFER_STATE  b )
2381 {
2382         if ( ! b )
2383                 return;
2384
2385         b->yy_n_chars = 0;
2386
2387         /* We always need two end-of-buffer characters.  The first causes
2388          * a transition to the end-of-buffer state.  The second causes
2389          * a jam in that state.
2390          */
2391         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2392         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2393
2394         b->yy_buf_pos = &b->yy_ch_buf[0];
2395
2396         b->yy_at_bol = 1;
2397         b->yy_buffer_status = YY_BUFFER_NEW;
2398
2399         if ( b == YY_CURRENT_BUFFER )
2400                 defargsYY_load_buffer_state( );
2401 }
2402
2403 /** Pushes the new state onto the stack. The new state becomes
2404  *  the current state. This function will allocate the stack
2405  *  if necessary.
2406  *  @param new_buffer The new state.
2407  *
2408  */
2409 void defargsYYpush_buffer_state (YY_BUFFER_STATE new_buffer )
2410 {
2411         if (new_buffer == NULL)
2412                 return;
2413
2414         defargsYYensure_buffer_stack();
2415
2416         /* This block is copied from defargsYY_switch_to_buffer. */
2417         if ( YY_CURRENT_BUFFER )
2418                 {
2419                 /* Flush out information for old buffer. */
2420                 *(yy_c_buf_p) = (yy_hold_char);
2421                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2422                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2423                 }
2424
2425         /* Only push if top exists. Otherwise, replace top. */
2426         if (YY_CURRENT_BUFFER)
2427                 (yy_buffer_stack_top)++;
2428         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2429
2430         /* copied from defargsYY_switch_to_buffer. */
2431         defargsYY_load_buffer_state( );
2432         (yy_did_buffer_switch_on_eof) = 1;
2433 }
2434
2435 /** Removes and deletes the top of the stack, if present.
2436  *  The next element becomes the new top.
2437  *
2438  */
2439 void defargsYYpop_buffer_state (void)
2440 {
2441         if (!YY_CURRENT_BUFFER)
2442                 return;
2443
2444         defargsYY_delete_buffer(YY_CURRENT_BUFFER );
2445         YY_CURRENT_BUFFER_LVALUE = NULL;
2446         if ((yy_buffer_stack_top) > 0)
2447                 --(yy_buffer_stack_top);
2448
2449         if (YY_CURRENT_BUFFER) {
2450                 defargsYY_load_buffer_state( );
2451                 (yy_did_buffer_switch_on_eof) = 1;
2452         }
2453 }
2454
2455 /* Allocates the stack if it does not exist.
2456  *  Guarantees space for at least one push.
2457  */
2458 static void defargsYYensure_buffer_stack (void)
2459 {
2460         yy_size_t num_to_alloc;
2461
2462         if (!(yy_buffer_stack)) {
2463
2464                 /* First allocation is just for 2 elements, since we don't know if this
2465                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2466                  * immediate realloc on the next call.
2467          */
2468                 num_to_alloc = 1;
2469                 (yy_buffer_stack) = (struct yy_buffer_state**)defargsYYalloc
2470                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
2471                                                                 );
2472                 if ( ! (yy_buffer_stack) )
2473                         YY_FATAL_ERROR( "out of dynamic memory in defargsYYensure_buffer_stack()" );
2474
2475                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2476
2477                 (yy_buffer_stack_max) = num_to_alloc;
2478                 (yy_buffer_stack_top) = 0;
2479                 return;
2480         }
2481
2482         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2483
2484                 /* Increase the buffer to prepare for a possible push. */
2485                 int grow_size = 8 /* arbitrary grow size */;
2486
2487                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2488                 (yy_buffer_stack) = (struct yy_buffer_state**)defargsYYrealloc
2489                                                                 ((yy_buffer_stack),
2490                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
2491                                                                 );
2492                 if ( ! (yy_buffer_stack) )
2493                         YY_FATAL_ERROR( "out of dynamic memory in defargsYYensure_buffer_stack()" );
2494
2495                 /* zero only the new slots.*/
2496                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2497                 (yy_buffer_stack_max) = num_to_alloc;
2498         }
2499 }
2500
2501 /** Setup the input buffer state to scan directly from a user-specified character buffer.
2502  * @param base the character buffer
2503  * @param size the size in bytes of the character buffer
2504  *
2505  * @return the newly allocated buffer state object.
2506  */
2507 YY_BUFFER_STATE defargsYY_scan_buffer  (char * base, yy_size_t  size )
2508 {
2509         YY_BUFFER_STATE b;
2510
2511         if ( size < 2 ||
2512              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2513              base[size-1] != YY_END_OF_BUFFER_CHAR )
2514                 /* They forgot to leave room for the EOB's. */
2515                 return 0;
2516
2517         b = (YY_BUFFER_STATE) defargsYYalloc(sizeof( struct yy_buffer_state )  );
2518         if ( ! b )
2519                 YY_FATAL_ERROR( "out of dynamic memory in defargsYY_scan_buffer()" );
2520
2521         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2522         b->yy_buf_pos = b->yy_ch_buf = base;
2523         b->yy_is_our_buffer = 0;
2524         b->yy_input_file = 0;
2525         b->yy_n_chars = b->yy_buf_size;
2526         b->yy_is_interactive = 0;
2527         b->yy_at_bol = 1;
2528         b->yy_fill_buffer = 0;
2529         b->yy_buffer_status = YY_BUFFER_NEW;
2530
2531         defargsYY_switch_to_buffer(b  );
2532
2533         return b;
2534 }
2535
2536 /** Setup the input buffer state to scan a string. The next call to defargsYYlex() will
2537  * scan from a @e copy of @a str.
2538  * @param yystr a NUL-terminated string to scan
2539  *
2540  * @return the newly allocated buffer state object.
2541  * @note If you want to scan bytes that may contain NUL values, then use
2542  *       defargsYY_scan_bytes() instead.
2543  */
2544 YY_BUFFER_STATE defargsYY_scan_string (yyconst char * yystr )
2545 {
2546
2547         return defargsYY_scan_bytes(yystr,strlen(yystr) );
2548 }
2549
2550 /** Setup the input buffer state to scan the given bytes. The next call to defargsYYlex() will
2551  * scan from a @e copy of @a bytes.
2552  * @param bytes the byte buffer to scan
2553  * @param len the number of bytes in the buffer pointed to by @a bytes.
2554  *
2555  * @return the newly allocated buffer state object.
2556  */
2557 YY_BUFFER_STATE defargsYY_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
2558 {
2559         YY_BUFFER_STATE b;
2560         char *buf;
2561         yy_size_t n, i;
2562
2563         /* Get memory for full buffer, including space for trailing EOB's. */
2564         n = _yybytes_len + 2;
2565         buf = (char *) defargsYYalloc(n  );
2566         if ( ! buf )
2567                 YY_FATAL_ERROR( "out of dynamic memory in defargsYY_scan_bytes()" );
2568
2569         for ( i = 0; i < _yybytes_len; ++i )
2570                 buf[i] = yybytes[i];
2571
2572         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2573
2574         b = defargsYY_scan_buffer(buf,n );
2575         if ( ! b )
2576                 YY_FATAL_ERROR( "bad buffer in defargsYY_scan_bytes()" );
2577
2578         /* It's okay to grow etc. this buffer, and we should throw it
2579          * away when we're done.
2580          */
2581         b->yy_is_our_buffer = 1;
2582
2583         return b;
2584 }
2585
2586 #ifndef YY_EXIT_FAILURE
2587 #define YY_EXIT_FAILURE 2
2588 #endif
2589
2590 static void yy_fatal_error (yyconst char* msg )
2591 {
2592         (void) fprintf( stderr, "%s\n", msg );
2593         exit( YY_EXIT_FAILURE );
2594 }
2595
2596 /* Redefine yyless() so it works in section 3 code. */
2597
2598 #undef yyless
2599 #define yyless(n) \
2600         do \
2601                 { \
2602                 /* Undo effects of setting up defargsYYtext. */ \
2603         int yyless_macro_arg = (n); \
2604         YY_LESS_LINENO(yyless_macro_arg);\
2605                 defargsYYtext[defargsYYleng] = (yy_hold_char); \
2606                 (yy_c_buf_p) = defargsYYtext + yyless_macro_arg; \
2607                 (yy_hold_char) = *(yy_c_buf_p); \
2608                 *(yy_c_buf_p) = '\0'; \
2609                 defargsYYleng = yyless_macro_arg; \
2610                 } \
2611         while ( 0 )
2612
2613 /* Accessor  methods (get/set functions) to struct members. */
2614
2615 /** Get the current line number.
2616  *
2617  */
2618 int defargsYYget_lineno  (void)
2619 {
2620
2621     return defargsYYlineno;
2622 }
2623
2624 /** Get the input stream.
2625  *
2626  */
2627 FILE *defargsYYget_in  (void)
2628 {
2629         return defargsYYin;
2630 }
2631
2632 /** Get the output stream.
2633  *
2634  */
2635 FILE *defargsYYget_out  (void)
2636 {
2637         return defargsYYout;
2638 }
2639
2640 /** Get the length of the current token.
2641  *
2642  */
2643 yy_size_t defargsYYget_leng  (void)
2644 {
2645         return defargsYYleng;
2646 }
2647
2648 /** Get the current token.
2649  *
2650  */
2651
2652 char *defargsYYget_text  (void)
2653 {
2654         return defargsYYtext;
2655 }
2656
2657 /** Set the current line number.
2658  * @param line_number
2659  *
2660  */
2661 void defargsYYset_lineno (int  line_number )
2662 {
2663
2664     defargsYYlineno = line_number;
2665 }
2666
2667 /** Set the input stream. This does not discard the current
2668  * input buffer.
2669  * @param in_str A readable stream.
2670  *
2671  * @see defargsYY_switch_to_buffer
2672  */
2673 void defargsYYset_in (FILE *  in_str )
2674 {
2675         defargsYYin = in_str ;
2676 }
2677
2678 void defargsYYset_out (FILE *  out_str )
2679 {
2680         defargsYYout = out_str ;
2681 }
2682
2683 int defargsYYget_debug  (void)
2684 {
2685         return defargsYY_flex_debug;
2686 }
2687
2688 void defargsYYset_debug (int  bdebug )
2689 {
2690         defargsYY_flex_debug = bdebug ;
2691 }
2692
2693 static int yy_init_globals (void)
2694 {
2695         /* Initialization is the same as for the non-reentrant scanner.
2696      * This function is called from defargsYYlex_destroy(), so don't allocate here.
2697      */
2698
2699     (yy_buffer_stack) = 0;
2700     (yy_buffer_stack_top) = 0;
2701     (yy_buffer_stack_max) = 0;
2702     (yy_c_buf_p) = (char *) 0;
2703     (yy_init) = 0;
2704     (yy_start) = 0;
2705
2706     (yy_state_buf) = 0;
2707     (yy_state_ptr) = 0;
2708     (yy_full_match) = 0;
2709     (yy_lp) = 0;
2710
2711 /* Defined in main.c */
2712 #ifdef YY_STDINIT
2713     defargsYYin = stdin;
2714     defargsYYout = stdout;
2715 #else
2716     defargsYYin = (FILE *) 0;
2717     defargsYYout = (FILE *) 0;
2718 #endif
2719
2720     /* For future reference: Set errno on error, since we are called by
2721      * defargsYYlex_init()
2722      */
2723     return 0;
2724 }
2725
2726 /* defargsYYlex_destroy is for both reentrant and non-reentrant scanners. */
2727 int defargsYYlex_destroy  (void)
2728 {
2729
2730     /* Pop the buffer stack, destroying each element. */
2731         while(YY_CURRENT_BUFFER){
2732                 defargsYY_delete_buffer(YY_CURRENT_BUFFER  );
2733                 YY_CURRENT_BUFFER_LVALUE = NULL;
2734                 defargsYYpop_buffer_state();
2735         }
2736
2737         /* Destroy the stack itself. */
2738         defargsYYfree((yy_buffer_stack) );
2739         (yy_buffer_stack) = NULL;
2740
2741     defargsYYfree ( (yy_state_buf) );
2742     (yy_state_buf)  = NULL;
2743
2744     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2745      * defargsYYlex() is called, initialization will occur. */
2746     yy_init_globals( );
2747
2748     return 0;
2749 }
2750
2751 /*
2752  * Internal utility routines.
2753  */
2754
2755 #ifndef yytext_ptr
2756 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
2757 {
2758         register int i;
2759         for ( i = 0; i < n; ++i )
2760                 s1[i] = s2[i];
2761 }
2762 #endif
2763
2764 #ifdef YY_NEED_STRLEN
2765 static int yy_flex_strlen (yyconst char * s )
2766 {
2767         register int n;
2768         for ( n = 0; s[n]; ++n )
2769                 ;
2770
2771         return n;
2772 }
2773 #endif
2774
2775 void *defargsYYalloc (yy_size_t  size )
2776 {
2777         return (void *) malloc( size );
2778 }
2779
2780 void *defargsYYrealloc  (void * ptr, yy_size_t  size )
2781 {
2782         /* The cast to (char *) in the following accommodates both
2783          * implementations that use char* generic pointers, and those
2784          * that use void* generic pointers.  It works with the latter
2785          * because both ANSI C and C++ allow castless assignment from
2786          * any pointer type to void*, and deal with argument conversions
2787          * as though doing an assignment.
2788          */
2789         return (void *) realloc( (char *) ptr, size );
2790 }
2791
2792 void defargsYYfree (void * ptr )
2793 {
2794         free( (char *) ptr );   /* see defargsYYrealloc() for (char *) cast */
2795 }
2796
2797 #define YYTABLES_NAME "yytables"
2798
2799 #line 486 "defargs.l"
2800
2801
2802
2803 /* ----------------------------------------------------------------------------
2804  */
2805
2806 /*! Converts an argument string into an ArgumentList.
2807  *  \param[in] argsString the list of Arguments.
2808  *  \param[out] al a reference to resulting argument list pointer.
2809  *  \param[out] extraTypeChars point to string to which trailing characters
2810  *              for complex types are written to
2811  */
2812
2813 void stringToArgumentList(const char *argsString,ArgumentList* al,QCString *extraTypeChars)
2814 {
2815   if (al==0) return;
2816   if (argsString==0) return;
2817
2818   g_copyArgValue=0;
2819   g_curArgDocs.resize(0);
2820   g_curArgAttrib.resize(0);
2821   g_curArgArray.resize(0);
2822   g_extraTypeChars.resize(0);
2823   g_argRoundCount = 0;
2824   g_argSharpCount = 0;
2825   g_argCurlyCount = 0;
2826   g_lastDocChar = 0;
2827
2828   g_inputString   = argsString;
2829   g_inputPosition = 0;
2830   g_curArgTypeName.resize(0);
2831   g_curArgDefValue.resize(0);
2832   g_curArgName.resize(0);
2833   g_argList = al;
2834   defargsYYrestart( defargsYYin );
2835   BEGIN( Start );
2836   defargsYYlex();
2837   if (extraTypeChars) *extraTypeChars=g_extraTypeChars;
2838   //printf("stringToArgumentList(%s) result=%s\n",argsString,argListToString(al).data());
2839 }
2840
2841 #if !defined(YY_FLEX_SUBMINOR_VERSION)
2842 extern "C" { // some bogus code to keep the compiler happy
2843   void defargsYYdummy() { yy_flex_realloc(0,0); }
2844 }
2845 #endif
2846
2847