gdb/ada-lex.c

   1 /* A lexical scanner generated by flex */
   2
   3 /* Scanner skeleton version:
   4  * $Header$
   5  * $FreeBSD: src/usr.bin/lex/flex.skl,v 1.4 1999/10/27 07:56:44 obrien Exp $
   6  */
   7
   8 #define FLEX_SCANNER
   9 #define YY_FLEX_MAJOR_VERSION 2
  10 #define YY_FLEX_MINOR_VERSION 5
  11
  12 #include <stdio.h>
  13
  14
  15 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  16 #ifdef c_plusplus
  17 #ifndef __cplusplus
  18 #define __cplusplus
  19 #endif
  20 #endif
  21
  22
  23 #ifdef __cplusplus
  24
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27
  28 /* Use prototypes in function declarations. */
  29 #define YY_USE_PROTOS
  30
  31 /* The "const" storage-class-modifier is valid. */
  32 #define YY_USE_CONST
  33
  34 #else   /* ! __cplusplus */
  35
  36 #if __STDC__
  37
  38 #define YY_USE_PROTOS
  39 #define YY_USE_CONST
  40
  41 #endif  /* __STDC__ */
  42 #endif  /* ! __cplusplus */
  43
  44 #ifdef __TURBOC__
  45  #pragma warn -rch
  46  #pragma warn -use
  47 #include <io.h>
  48 #include <stdlib.h>
  49 #define YY_USE_CONST
  50 #define YY_USE_PROTOS
  51 #endif
  52
  53 #ifdef YY_USE_CONST
  54 #define yyconst const
  55 #else
  56 #define yyconst
  57 #endif
  58
  59
  60 #ifdef YY_USE_PROTOS
  61 #define YY_PROTO(proto) proto
  62 #else
  63 #define YY_PROTO(proto) ()
  64 #endif
  65
  66 /* Returned upon end-of-file. */
  67 #define YY_NULL 0
  68
  69 /* Promotes a possibly negative, possibly signed char to an unsigned
  70  * integer for use as an array index.  If the signed char is negative,
  71  * we want to instead treat it as an 8-bit unsigned char, hence the
  72  * double cast.
  73  */
  74 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  75
  76 /* Enter a start condition.  This macro really ought to take a parameter,
  77  * but we do it the disgusting crufty way forced on us by the ()-less
  78  * definition of BEGIN.
  79  */
  80 #define BEGIN yy_start = 1 + 2 *
  81
  82 /* Translate the current start state into a value that can be later handed
  83  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  84  * compatibility.
  85  */
  86 #define YY_START ((yy_start - 1) / 2)
  87 #define YYSTATE YY_START
  88
  89 /* Action number for EOF rule of a given start state. */
  90 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  91
  92 /* Special action meaning "start processing a new file". */
  93 #define YY_NEW_FILE yyrestart( yyin )
  94
  95 #define YY_END_OF_BUFFER_CHAR 0
  96
  97 /* Size of default input buffer. */
  98 #define YY_BUF_SIZE 16384
  99
 100 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 101
 102 extern int yyleng;
 103 extern FILE *yyin, *yyout;
 104
 105 #define EOB_ACT_CONTINUE_SCAN 0
 106 #define EOB_ACT_END_OF_FILE 1
 107 #define EOB_ACT_LAST_MATCH 2
 108
 109 /* The funky do-while in the following #define is used to turn the definition
 110  * int a single C statement (which needs a semi-colon terminator).  This
 111  * avoids problems with code like:
 112  *
 113  *      if ( condition_holds )
 114  *              yyless( 5 );
 115  *      else
 116  *              do_something_else();
 117  *
 118  * Prior to using the do-while the compiler would get upset at the
 119  * "else" because it interpreted the "if" statement as being all
 120  * done when it reached the ';' after the yyless() call.
 121  */
 122
 123 /* Return all but the first 'n' matched characters back to the input stream. */
 124
 125 #define yyless(n) \
 126         do \
 127                 { \
 128                 /* Undo effects of setting up yytext. */ \
 129                 *yy_cp = yy_hold_char; \
 130                 YY_RESTORE_YY_MORE_OFFSET \
 131                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
 132                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 133                 } \
 134         while ( 0 )
 135
 136 #define unput(c) yyunput( c, yytext_ptr )
 137
 138 /* The following is because we cannot portably get our hands on size_t
 139  * (without autoconf's help, which isn't available because we want
 140  * flex-generated scanners to compile on their own).
 141  */
 142 typedef unsigned int yy_size_t;
 143
 144
 145 struct yy_buffer_state
 146         {
 147         FILE *yy_input_file;
 148
 149         char *yy_ch_buf;                /* input buffer */
 150         char *yy_buf_pos;               /* current position in input buffer */
 151
 152         /* Size of input buffer in bytes, not including room for EOB
 153          * characters.
 154          */
 155         yy_size_t yy_buf_size;
 156
 157         /* Number of characters read into yy_ch_buf, not including EOB
 158          * characters.
 159          */
 160         int yy_n_chars;
 161
 162         /* Whether we "own" the buffer - i.e., we know we created it,
 163          * and can realloc() it to grow it, and should free() it to
 164          * delete it.
 165          */
 166         int yy_is_our_buffer;
 167
 168         /* Whether this is an "interactive" input source; if so, and
 169          * if we're using stdio for input, then we want to use getc()
 170          * instead of fread(), to make sure we stop fetching input after
 171          * each newline.
 172          */
 173         int yy_is_interactive;
 174
 175         /* Whether we're considered to be at the beginning of a line.
 176          * If so, '^' rules will be active on the next match, otherwise
 177          * not.
 178          */
 179         int yy_at_bol;
 180
 181         /* Whether to try to fill the input buffer when we reach the
 182          * end of it.
 183          */
 184         int yy_fill_buffer;
 185
 186         int yy_buffer_status;
 187 #define YY_BUFFER_NEW 0
 188 #define YY_BUFFER_NORMAL 1
 189         /* When an EOF's been seen but there's still some text to process
 190          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 191          * shouldn't try reading from the input source any more.  We might
 192          * still have a bunch of tokens to match, though, because of
 193          * possible backing-up.
 194          *
 195          * When we actually see the EOF, we change the status to "new"
 196          * (via yyrestart()), so that the user can continue scanning by
 197          * just pointing yyin at a new input file.
 198          */
 199 #define YY_BUFFER_EOF_PENDING 2
 200         };
 201
 202 static YY_BUFFER_STATE yy_current_buffer = 0;
 203
 204 /* We provide macros for accessing buffer states in case in the
 205  * future we want to put the buffer states in a more general
 206  * "scanner state".
 207  */
 208 #define YY_CURRENT_BUFFER yy_current_buffer
 209
 210
 211 /* yy_hold_char holds the character lost when yytext is formed. */
 212 static char yy_hold_char;
 213
 214 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 215
 216
 217 int yyleng;
 218
 219 /* Points to current character in buffer. */
 220 static char *yy_c_buf_p = (char *) 0;
 221 static int yy_init = 1;         /* whether we need to initialize */
 222 static int yy_start = 0;        /* start state number */
 223
 224 /* Flag which is used to allow yywrap()'s to do buffer switches
 225  * instead of setting up a fresh yyin.  A bit of a hack ...
 226  */
 227 static int yy_did_buffer_switch_on_eof;
 228
 229 void yyrestart YY_PROTO(( FILE *input_file ));
 230
 231 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 232 void yy_load_buffer_state YY_PROTO(( void ));
 233 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
 234 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 235 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
 236 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 237 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 238
 239 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
 240 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
 241 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 242
 243 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
 244 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 245 static void yy_flex_free YY_PROTO(( void * ));
 246
 247 #define yy_new_buffer yy_create_buffer
 248
 249 #define yy_set_interactive(is_interactive) \
 250         { \
 251         if ( ! yy_current_buffer ) \
 252                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 253         yy_current_buffer->yy_is_interactive = is_interactive; \
 254         }
 255
 256 #define yy_set_bol(at_bol) \
 257         { \
 258         if ( ! yy_current_buffer ) \
 259                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 260         yy_current_buffer->yy_at_bol = at_bol; \
 261         }
 262
 263 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 264
 265
 266 #define YY_USES_REJECT
 267 typedef unsigned char YY_CHAR;
 268 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 269 typedef int yy_state_type;
 270 extern char *yytext;
 271 #define yytext_ptr yytext
 272
 273 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 274 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 275 static int yy_get_next_buffer YY_PROTO(( void ));
 276 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 277
 278 /* Done after the current pattern has been matched and before the
 279  * corresponding action - sets up yytext.
 280  */
 281 #define YY_DO_BEFORE_ACTION \
 282         yytext_ptr = yy_bp; \
 283         yyleng = (int) (yy_cp - yy_bp); \
 284         yy_hold_char = *yy_cp; \
 285         *yy_cp = '\0'; \
 286         yy_c_buf_p = yy_cp;
 287
 288 #define YY_NUM_RULES 57
 289 #define YY_END_OF_BUFFER 58
 290 static yyconst short int yy_acclist[386] =
 291     {   0,
 292        58,   56,   57,    1,   56,   57,    1,   57,   15,   56,
 293        57,   53,   56,   57,   41,   56,   57,   56,   57,   43,
 294        56,   57,   44,   56,   57,   41,   56,   57,   42,   56,
 295        57,   41,   56,   57,   41,   56,   57,   41,   56,   57,
 296         4,   56,   57,    4,   56,   57,   41,   56,   57,   41,
 297        56,   57,   41,   56,   57,   41,   56,   57,   50,   56,
 298        57,   47,   56,   57,   47,   56,   57,   47,   56,   57,
 299        47,   56,   57,   47,   56,   57,   47,   56,   57,   47,
 300        56,   57,   47,   56,   57,   47,   56,   57,   47,   56,
 301        57,    1,   56,   57,   56,   57,   16,   56,   57,   53,
 302
 303        56,   57,   41,   56,   57,   56,   57,   43,   56,   57,
 304        44,   56,   57,   41,   56,   57,   42,   56,   57,   41,
 305        56,   57,   41,   56,   57,   41,   56,   57,    4,   56,
 306        57,    4,   56,   57,   41,   56,   57,   41,   56,   57,
 307        41,   56,   57,   41,   56,   57,   50,   56,   57,   41,
 308        56,   57,   47,   56,   57,   47,   56,   57,   47,   56,
 309        57,   47,   56,   57,   47,   56,   57,   47,   56,   57,
 310        47,   56,   57,   47,   56,   57,   47,   56,   57,   47,
 311        56,   57,   56,   57,   40,   56,   57,   51,   55,   54,
 312        55,   55,   35,    2,   34,   46,   46,   37,    4,   36,
 313
 314        38,   33,   39,   47,   47,   47,   47,   47,   19,   47,
 315        23,   47,   47,   47,   47,   47,   28,   47,   47,   47,
 316        47,   16,   51,   55,   54,   55,   55,   16,   35,    2,
 317        34,   46,   46,   37,    4,   36,   38,   33,   39,   16,
 318        47,   47,   47,   47,   47,   19,   47,   23,   47,   47,
 319        47,   47,   47,   28,   47,   47,   47,   47,16398,   52,
 320        55,   12,   12,   32,    2,   46,   46,    9,    3,    7,
 321        47,   47,   49,   20,   47,   21,   47,   47,   24,   47,
 322        25,   47,   26,   47,   47,   29,   47,   47,   31,   47,
 323        52,   55,   16,   32,    2,    2,   16,    2,   46,   46,
 324
 325         9,    3,    7,   47,   16,   47,   49,   20,   47,   21,
 326        47,   47,   24,   47,   25,   47,   26,   47,   47,   29,
 327        47,   47,   31,   47, 8206,   46,   45,   46,    6,    9,
 328         3,   47,   22,   47,   27,   47,   30,   47,    2,   16,
 329        46,   45,   46,    6,    9,    3,   47,   22,   47,   27,
 330        47,   30,   47,   48,   47,   48,    2,    2,   18,   47,
 331         5,   11,    8,   18,    2,    2,    5,   11,    8,   17,
 332         5,    8,   17,    2,   18,    2,    5,    8,   13,    2,
 333        17,   10,   10,   10,   10
 334     } ;
 335
 336 static yyconst short int yy_accept[364] =
 337     {   0,
 338         1,    1,    1,    1,    1,    1,    1,    2,    4,    7,
 339         9,   12,   15,   18,   20,   23,   26,   29,   32,   35,
 340        38,   41,   44,   47,   50,   53,   56,   59,   62,   65,
 341        68,   71,   74,   77,   80,   83,   86,   89,   92,   95,
 342        97,  100,  103,  106,  108,  111,  114,  117,  120,  123,
 343       126,  129,  132,  135,  138,  141,  144,  147,  150,  153,
 344       156,  159,  162,  165,  168,  171,  174,  177,  180,  183,
 345       185,  188,  188,  188,  188,  188,  188,  188,  188,  188,
 346       188,  188,  188,  190,  192,  193,  193,  193,  193,  193,
 347       193,  193,  193,  194,  195,  195,  196,  196,  197,  198,
 348
 349       199,  199,  199,  200,  200,  200,  201,  202,  202,  203,
 350       204,  204,  204,  205,  205,  206,  206,  207,  208,  209,
 351       211,  213,  214,  215,  216,  217,  219,  220,  221,  222,
 352       222,  223,  223,  225,  227,  228,  228,  228,  229,  229,
 353       229,  230,  231,  231,  232,  232,  233,  234,  235,  235,
 354       235,  236,  236,  236,  237,  238,  238,  239,  240,  241,
 355       241,  242,  242,  243,  243,  244,  245,  246,  248,  250,
 356       251,  252,  253,  254,  256,  257,  258,  259,  259,  260,
 357       260,  260,  260,  260,  260,  260,  262,  262,  263,  264,
 358       264,  265,  266,  266,  267,  268,  268,  269,  269,  270,
 359
 360       271,  271,  272,  272,  272,  272,  273,  274,  276,  278,
 361       279,  281,  283,  285,  286,  288,  289,  291,  293,  293,
 362       294,  295,  296,  298,  299,  299,  300,  301,  301,  302,
 363       302,  303,  304,  304,  305,  305,  305,  305,  306,  306,
 364       307,  308,  310,  312,  313,  315,  317,  319,  320,  322,
 365       323,  325,  325,  326,  326,  326,  326,  326,  327,  329,
 366       330,  330,  330,  331,  331,  332,  332,  332,  332,  332,
 367       332,  332,  332,  332,  332,  332,  332,  332,  333,  335,
 368       337,  339,  339,  339,  339,  339,  341,  341,  342,  344,
 369       345,  345,  345,  346,  346,  347,  347,  347,  347,  348,
 370
 371       350,  352,  354,  355,  355,  355,  355,  355,  356,  356,
 372       356,  356,  356,  356,  356,  356,  357,  357,  357,  358,
 373       359,  359,  359,  359,  360,  360,  360,  361,  361,  361,
 374       362,  363,  363,  364,  365,  365,  366,  367,  367,  368,
 375       369,  369,  370,  371,  371,  372,  372,  373,  374,  376,
 376       377,  378,  378,  379,  380,  380,  382,  382,  383,  384,
 377       385,  386,  386
 378     } ;
 379
 380 static yyconst int yy_ec[256] =
 381     {   0,
 382         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 383         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 384         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 385         1,    4,    5,    6,    7,    8,    5,    9,   10,   11,
 386        12,   13,   14,   15,   16,   17,   18,   19,   20,   20,
 387        20,   20,   20,   20,   20,   20,   20,   21,   22,   23,
 388        24,   25,    5,   26,   30,   31,   32,   33,   34,   35,
 389        36,   37,   38,   36,   36,   39,   40,   41,   42,   36,
 390        36,   43,   44,   45,   46,   36,   47,   48,   36,   36,
 391        27,    5,   28,    5,   29,    5,   30,   31,   32,   33,
 392
 393        34,   35,   36,   37,   38,   36,   36,   39,   40,   41,
 394        42,   36,   36,   43,   44,   45,   46,   36,   47,   48,
 395        36,   36,   26,   22,   26,    5,    1,    1,    1,    1,
 396         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 397         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 398         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 399         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 400         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 401         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 402         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 403
 404         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 405         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 406         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 407         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 408         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 409         1,    1,    1,    1,    1
 410     } ;
 411
 412 static yyconst int yy_meta[49] =
 413     {   0,
 414         1,    2,    3,    4,    5,    6,    7,    8,    5,    9,
 415         5,    5,    5,    5,    5,    5,   10,    5,   11,   11,
 416         9,    5,   12,   13,   14,    5,    5,    5,   15,   16,
 417        16,   16,   16,   16,   16,   17,   17,   17,   17,   17,
 418        17,   17,   17,   17,   17,   17,   17,   17
 419     } ;
 420
 421 static yyconst short int yy_base[385] =
 422     {   0,
 423         0,    0,   48,    0,   91,   92, 1405, 1771, 1771, 1771,
 424        94,   96, 1771,  142, 1771, 1771, 1391, 1771, 1387,  189,
 425      1378,  188,  194, 1377, 1376, 1374, 1361, 1771,  222,  242,
 426        82,   91,   89,  196,   68,  163,  179,   97,  100,  194,
 427         0,  280,  223,  328,  227,  228,  234,  229,  235,  375,
 428       242,  418, 1335,  243,  463,  247,  251,  252,  254,  510,
 429       168, 1343,  161, 1333,  234, 1331, 1336, 1323, 1316,    0,
 430       558, 1340,  127,  258,  420,  422,  398, 1299, 1285, 1258,
 431      1266, 1257,  411,  413,    0,  605, 1288, 1287, 1286, 1285,
 432       119,  644, 1771,    0,  691, 1771,    0,    0, 1255, 1771,
 433
 434         0,  421,  690,  429,    0, 1771, 1771, 1244, 1771, 1771,
 435       608,  696, 1771,  699,  419, 1247,  420,  422,  582,  583,
 436       586,  587,  624,  625,  591,  590,  627,  628,  684,  430,
 437      1771,  705,  653, 1256,  710, 1252,  731,    0, 1254,  750,
 438       710,  798, 1222,  717,  802,  832, 1199,  720,  875,  730,
 439      1189,  732,  892,  733,  795,  924,  796,  797, 1230,  971,
 440       800,  997,    0,  876, 1183, 1191, 1176,    0,    0, 1174,
 441      1151, 1150, 1097,    0, 1095, 1100, 1089, 1096,  805, 1043,
 442      1047, 1043, 1023, 1016, 1010,  439,  808,  883, 1771, 1027,
 443      1041,    0,  971,    0,  952,  736,  864,  614,  799,    0,
 444
 445       965,  976, 1046, 1061,    0, 1061, 1771,  714,  717,  858,
 446       774,  789,  859, 1042,  860,  953,  954, 1047, 1086, 1108,
 447         0, 1092,    0, 1094, 1140,    0,  950, 1182, 1091, 1110,
 448      1199, 1210,    0, 1244,  981,    0,    0,    0, 1243, 1273,
 449       890,    0,    0,  949,    0,    0,    0,  943,    0,  935,
 450         0, 1120, 1771, 1188,  900, 1303,  895, 1771,    0,  882,
 451         0, 1098, 1174,  440, 1177,  909,  421, 1048, 1093, 1102,
 452      1169,  846,  818,  814,  822,  779,  792, 1249, 1190, 1191,
 453      1192, 1322, 1228,  750, 1331, 1361,    0, 1106,    0, 1229,
 454      1378,    0, 1325, 1326, 1349,  726,  725, 1410,    0,    0,
 455
 456         0,    0, 1771,  722,  839,  713,  644, 1369,  668,  671,
 457       663,  615,  617,  576,  591, 1198,  540,  459,  456, 1440,
 458      1462, 1483, 1458, 1771,  414,    0, 1517,  249,  794, 1238,
 459       237,  258, 1310,    0,  203,  190,  209, 1460, 1477, 1350,
 460         0, 1480, 1771,  131, 1328,  726, 1472,    0,    0,   86,
 461      1516, 1523, 1522, 1385,  835,    0, 1505, 1511, 1527, 1533,
 462      1549, 1771, 1571, 1587, 1592, 1608, 1622, 1639, 1642, 1649,
 463        89,  187, 1656, 1672, 1689, 1701, 1707, 1718, 1720, 1736,
 464       902,  903, 1743, 1754
 465     } ;
 466
 467 static yyconst short int yy_def[385] =
 468     {   0,
 469       362,    1,  362,    3,    1,    1,  362,  362,  362,  362,
 470       362,  363,  362,  362,  362,  362,  362,  362,  362,  364,
 471       362,  362,  362,  362,  365,  362,  362,  362,  366,  366,
 472        30,   30,   30,   30,   30,   30,   30,   30,  367,  367,
 473        11,  362,  367,  362,  367,  367,  367,  367,  367,  362,
 474       367,  367,   52,  367,  362,  367,  367,  367,  367,  362,
 475        60,   60,   60,   60,   60,   60,   60,   60,   60,   11,
 476       362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
 477       362,  362,  363,  363,  363,   71,   71,   71,   86,  362,
 478        86,   86,  362,  368,  364,  362,  369,  370,  370,  362,
 479
 480       371,  362,  362,  362,  372,  362,  362,  373,  362,  362,
 481       362,  362,  362,  374,   30,  362,   30,   30,   30,   30,
 482        30,   30,   30,   30,   30,   30,   30,   30,   30,  367,
 483       362,  367,   42,   42,   42,   44,   44,   86,  137,  137,
 484       367,  375,   50,  367,   55,  145,  146,  367,  367,  367,
 485        52,  367,  149,  367,  367,  362,  367,  367,  376,  367,
 486       367,  362,   60,  367,   60,   60,   60,   60,   60,   60,
 487        60,   60,   60,   60,   60,   60,   60,   92,  362,  362,
 488       362,  362,  362,  362,  362,  363,  362,  362,  362,   86,
 489        92,  368,  377,  370,  370,  378,  362,  362,  362,  372,
 490
 491       373,  362,  374,  362,  379,  380,  362,   30,   30,   30,
 492        30,   30,   30,   30,   30,   30,   30,   42,  367,   86,
 493       140,  375,  368,  375,  362,  146,  146,  149,  367,  367,
 494       367,  149,  156,  367,  362,  381,  162,  204,  145,   60,
 495       367,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 496        60,  362,  362,  362,  362,   86,  377,  362,  370,  362,
 497       382,  378,  362,  362,  362,  362,  362,  362,  362,  362,
 498       362,  362,  362,  362,  362,  362,  383,  380,   30,   30,
 499        30,  367,  367,   86,   86,  368,  225,  367,  146,  367,
 500       149,  228,  367,  367,  367,  362,  362,  362,  240,   60,
 501
 502        60,   60,  362,   86,  362,  384,  362,  362,  362,  362,
 503       362,  362,  362,  362,  383,  367,   86,   86,  368,  368,
 504       367,  149,  367,  362,  362,  298,  367,   86,  362,  362,
 505       362,  384,  362,   86,   86,  368,  368,  367,  367,  367,
 506       322,  367,  362,   86,  362,  362,  362,   86,  368,  368,
 507       367,  367,  367,  362,  362,  368,  367,  362,  367,  362,
 508       367,    0,  362,  362,  362,  362,  362,  362,  362,  362,
 509       362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
 510       362,  362,  362,  362
 511     } ;
 512
 513 static yyconst short int yy_nxt[1820] =
 514     {   0,
 515         8,    9,   10,    9,    8,   11,    8,   12,   13,   14,
 516        15,   16,   17,   13,   18,   19,   20,   21,   22,   23,
 517        24,   13,   25,   26,   27,   28,   13,   13,   29,   30,
 518        29,   29,   29,   31,   29,   29,   29,   32,   29,   33,
 519        34,   35,   36,   29,   37,   29,   29,   38,    8,    9,
 520        10,   39,   40,   41,   40,   42,   43,   44,   45,   46,
 521        47,   43,   48,   49,   50,   51,   52,   53,   54,   43,
 522        55,   56,   57,   58,   59,   43,   60,   61,   60,   60,
 523        60,   62,   60,   60,   60,   63,   60,   64,   65,   66,
 524        67,   60,   68,   60,   60,   69,   70,   70,  115,  196,
 525
 526        71,   71,   72,   83,  196,  131,   73,   72,  115,   72,
 527       126,   74,  115,  356,   84,   84,   75,   72,   76,  115,
 528       119,  115,  115,   77,  190,  120,  132,  115,  188,  115,
 529       122,  121,  179,   78,   79,   80,   81,  115,  129,   72,
 530       354,   82,   86,   87,   87,   88,   89,   89,   89,   89,
 531        89,   90,   89,   89,   89,   89,   89,   89,   89,   89,
 532        89,   89,   89,   89,   89,   89,   89,   89,   91,   89,
 533        89,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 534        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 535        95,   95,   95,  115,  101,  168,  127,  200,  165,  131,
 536
 537       101,  169,  200,  115,  102,   96,  103,  103,  166,  115,
 538       102,   97,  103,  103,  350,  128,  103,  349,   99,  115,
 539       132,  104,  103,  111,  111,  112,  115,  104,  131,  123,
 540       348,  113,  131,  131,  131,  105,  115,  124,  114,  131,
 541       131,  125,  116,  111,  111,  112,  141,  131,  131,  132,
 542       142,  113,  131,  132,  132,  132,  131,  131,  114,  159,
 543       132,  132,  116,  179,  331,  148,  154,  171,  132,  132,
 544       346,  157,  117,  132,  158,  172,  344,  132,  132,  173,
 545       132,   72,  118,  130,  130,  131,  130,  133,  130,  130,
 546       130,  130,  130,  130,  130,  130,  130,  130,  134,  134,
 547
 548       130,  130,  130,  130,  130,  130,  132,  130,  135,  135,
 549       135,  135,  135,  135,  135,  135,  135,  135,  135,  135,
 550       135,  135,  135,  135,  135,  135,  135,  135,   86,   87,
 551        87,  136,  137,  138,  137,  137,  137,  130,  137,  137,
 552       137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
 553       137,  137,  137,  137,  139,  137,  137,  140,  140,  140,
 554       140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
 555       140,  140,  140,  140,  140,  140,   95,   95,  143,  130,
 556       131,  130,  130,  130,  130,  130,  130,  130,  130,  130,
 557       130,  144,  130,  130,  130,  130,  130,  145,  130,  130,
 558
 559       130,  132,  130,  146,  147,  146,  146,  146,  146,  146,
 560       146,  146,  146,  146,  146,  146,  146,  146,  146,  146,
 561       146,  146,  146,  131,  149,  179,  308,  179,  180,  186,
 562       186,   84,   84,  266,  150,  131,  151,  151,  181,  197,
 563       197,  343,  198,   72,  132,   72,  151,  199,  199,  115,
 564       115,  152,  115,  307,  209,  307,  132,  186,  186,  115,
 565       115,  336,  115,  208,  335,  153,  130,  130,  131,  130,
 566       130,  130,  130,  130,  130,  130,  130,  130,  130,  130,
 567       130,  130,  130,  130,  130,  130,  155,  130,  130,  132,
 568       130,  156,  156,  156,  156,  156,  156,  156,  156,  156,
 569
 570       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
 571       156,  111,  111,  160,  130,  131,  130,  130,  130,  161,
 572       130,  130,  130,  130,  130,  130,  162,  130,  163,  163,
 573       164,  130,  130,  130,  130,  130,  132,  130,  163,  163,
 574       163,  163,  163,  163,  163,  163,  163,  163,  163,  163,
 575       163,  163,  163,  163,  163,  163,  163,  163,   86,   87,
 576        87,   87,   86,   86,   86,   86,   86,  334,   86,   86,
 577        86,   86,   86,   86,   86,   86,   86,   86,   86,   86,
 578        86,   86,   86,   86,   86,   86,   86,  178,  178,  178,
 579       178,  178,  178,  178,  178,  178,  178,  178,  178,  178,
 580
 581       178,  178,  178,  178,  178,  178,   86,   86,   86,  111,
 582       111,  111,  115,  115,  187,  308,  115,  115,  266,  211,
 583       115,  115,  115,  115,  114,  210,  115,  115,  116,  214,
 584       115,  115,  199,  199,   86,   86,   86,   86,   86,   86,
 585        86,   86,   86,   86,   86,   86,   86,   86,   86,   86,
 586        86,   86,   86,  188,  115,  115,  266,  115,  115,  266,
 587       135,  216,  333,  333,  115,  115,  215,  115,  115,  213,
 588       212,  218,  218,  191,  191,  191,  191,  191,  191,  191,
 589       191,  191,  191,  191,  191,  191,  191,  191,  191,  191,
 590       191,  191,   95,   95,   95,  266,  101,  111,  111,  112,
 591
 592       203,  203,  203,  266,  204,  113,  102,  362,  103,  103,
 593       159,  266,  114,   97,  115,  131,  116,  135,  103,  331,
 594        99,  205,  131,  104,  115,  131,  217,  328,  135,  135,
 595       325,  132,   86,   86,  137,  131,  132,  131,  131,  355,
 596       219,  355,  260,  132,  115,  230,  132,  115,  229,  229,
 597       231,  231,  261,  324,  115,  317,  132,  115,  132,  132,
 598       137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
 599       137,  137,  137,  137,  137,  137,  137,  137,  137,  221,
 600       221,  221,  221,  221,  221,  221,  221,  221,  221,  221,
 601       221,  221,  221,  221,  221,  221,  221,  221,  192,  192,
 602
 603       131,  131,  131,  223,  115,  131,  252,  252,  252,  254,
 604       254,  254,  330,  330,  115,  253,  308,  265,  265,  115,
 605       314,  132,  132,  132,  224,  130,  132,  265,  255,  115,
 606       225,  225,  225,  225,  225,  225,  225,  225,  225,  225,
 607       225,  225,  225,  225,  225,  225,  225,  225,  225,  225,
 608       226,  226,  329,  358,  358,  313,  266,  330,  330,  312,
 609       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
 610       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
 611       131,  131,  263,  263,  254,  254,  254,  311,  115,  115,
 612       115,  279,  263,  228,  228,  131,  241,  264,  115,  115,
 613
 614       115,  132,  132,  255,  228,  228,  228,  228,  228,  228,
 615       232,  232,  297,  306,  308,  305,  132,  297,  306,  258,
 616       303,  232,  232,  232,  232,  232,  232,  130,  130,  131,
 617       130,  130,  130,  130,  130,  130,  130,  130,  130,  130,
 618       130,  130,  233,  233,  130,  130,  130,  130,  234,  130,
 619       132,  130,  233,  233,  233,  233,  233,  233,  233,  233,
 620       233,  233,  233,  233,  233,  233,  233,  233,  233,  233,
 621       233,  233,  111,  111,  160,  302,  131,  111,  111,  112,
 622       161,  301,  300,  115,  115,  113,  296,  162,  289,  202,
 623       259,  164,  114,  281,  115,  258,  116,  132,  203,  203,
 624
 625       237,  130,  238,  130,  130,  130,  130,  130,  130,  130,
 626       130,  130,  130,  130,  130,  130,  130,  130,  130,  239,
 627       130,  130,  130,  132,  130,  240,  240,  240,  240,  240,
 628       240,  240,  240,  240,  240,  240,  240,  240,  240,  240,
 629       240,  240,  240,  240,  240,  256,  256,  203,  203,  203,
 630       187,  204,   72,  308,  135,   72,  256,  256,  256,  256,
 631       256,  256,  111,  111,  112,  218,  218,   72,  205,  266,
 632       113,  266,  115,  267,  266,   72,  266,  114,  268,   72,
 633       280,  116,  115,  269,  266,  270,   72,  254,  254,  282,
 634       271,  131,  192,  192,  192,  192,  131,  223,  308,  286,
 635
 636       272,  273,  274,  275,  260,  187,  283,  308,  276,  293,
 637       293,  131,  132,  284,  261,  131,  266,  132,  224,  293,
 638       224,  252,  252,  252,  294,  266,  285,  285,  231,  231,
 639       253,  251,  132,  250,  249,  248,  132,  285,  285,  285,
 640       285,  285,  285,  130,  130,  131,  130,  130,  130,  130,
 641       130,  130,  130,  130,  130,  130,  130,  130,  287,  287,
 642       130,  130,  130,  130,  288,  130,  132,  130,  287,  287,
 643       287,  287,  287,  287,  287,  287,  287,  287,  287,  287,
 644       287,  287,  287,  287,  287,  287,  287,  287,  290,  254,
 645       254,  254,  263,  263,  247,  265,  265,  246,  291,  309,
 646
 647       292,  292,  263,  131,  131,  265,  245,  264,  255,  310,
 648       292,  292,  292,  292,  292,  292,  292,  295,  295,  244,
 649       115,  115,  115,  243,  132,  132,  242,  295,  232,  232,
 650       115,  115,  115,  131,  131,  235,  130,  227,  130,  232,
 651       232,  232,  232,  232,  232,  111,  111,  160,  316,  131,
 652       111,  111,  112,  161,  132,  132,  345,  345,  113,  220,
 653       162,  219,  321,  135,  164,  114,  345,  207,  202,  116,
 654       132,  298,  298,  298,  298,  298,  298,  298,  298,  298,
 655       298,  298,  298,  298,  298,  298,  298,  298,  298,  298,
 656       298,  299,  299,  195,  189,  188,  188,  187,  185,  184,
 657
 658        72,  299,  299,  299,  299,  299,  299,  299,  299,  299,
 659       299,  299,  299,  299,  299,  299,  299,  299,  299,  299,
 660       299,  304,  304,  254,  254,  282,  183,  131,  347,  347,
 661       131,  131,  304,  304,  304,  304,  304,  304,  347,  323,
 662       182,  323,  283,  293,  293,  179,  345,  345,  132,  318,
 663       318,  132,  132,  293,  131,  131,  345,  177,  294,  176,
 664       318,  318,  318,  318,  318,  318,  319,  295,  295,  175,
 665       111,  111,  112,  174,  170,  132,  132,  295,  113,  320,
 666       320,  167,  130,  352,  110,  114,  254,  254,  254,  116,
 667       320,  320,  320,  320,  320,  320,  322,  322,  109,  107,
 668
 669       106,  100,   94,   93,  362,  255,  362,  322,  322,  322,
 670       322,  322,  322,  130,  130,  131,  130,  130,  130,  130,
 671       130,  130,  130,  130,  130,  130,  130,  130,  326,  326,
 672       130,  130,  130,  130,  327,  130,  132,  130,  326,  326,
 673       326,  326,  326,  326,  326,  326,  326,  326,  326,  326,
 674       326,  326,  326,  326,  326,  326,  326,  326,  337,  337,
 675       362,  362,  362,  131,  362,  131,  362,  131,  362,  337,
 676       337,  337,  337,  337,  337,  338,  342,  342,  339,  339,
 677       339,  339,  131,  362,  132,  131,  132,  362,  132,  340,
 678       347,  347,  362,  362,  362,  351,  351,  362,  353,  353,
 679
 680       347,  341,  341,  132,  362,  351,  132,  362,  353,  362,
 681       131,  341,  341,  341,  341,  341,  341,  341,  111,  111,
 682       160,  131,  131,  359,  359,  362,  161,  131,  131,  360,
 683       360,  132,  131,  162,  351,  351,  357,  164,  357,  360,
 684       353,  353,  132,  132,  351,  361,  361,  362,  132,  132,
 685       353,  360,  360,  132,  131,  361,  362,  362,  362,  362,
 686       362,  360,  362,  362,  362,  362,  362,  361,  361,  362,
 687       362,  362,  362,  362,  362,  132,  362,  361,   85,  362,
 688       362,   85,  362,  362,  362,   85,   85,   85,   98,   98,
 689        98,  362,  362,  362,  362,  362,   98,  362,   98,  362,
 690
 691       362,   98,   98,   98,  108,  362,  108,  108,  108,  115,
 692       115,  115,  362,  362,  362,  362,  115,  115,  115,  362,
 693       362,  362,  115,  115,  115,  130,  130,  130,  130,  130,
 694       130,  130,  130,  130,  130,  130,  130,  130,  130,  192,
 695       192,  362,  192,  192,  192,  192,  192,  192,  192,  192,
 696       192,  192,  192,  192,  192,  192,  193,  193,  193,  194,
 697       362,  362,  362,  194,  194,  194,  201,  362,  362,  201,
 698       201,  201,  201,  206,  206,  206,  362,  206,  362,  362,
 699       362,  362,  362,  206,  362,  362,  206,  206,  206,  222,
 700       222,  362,  222,  222,  222,  222,  222,  222,  222,  222,
 701
 702       222,  222,  222,  222,  222,  222,  236,  362,  362,  362,
 703       362,  236,  362,  362,  362,  362,  236,  257,  362,  362,
 704       257,  257,  257,  257,  262,  362,  362,  262,  262,  362,
 705       362,  362,  262,  262,  277,  277,  277,  278,  278,  278,
 706       362,  362,  362,  362,  278,  278,  278,  362,  362,  362,
 707       278,  278,  278,  315,  362,  362,  315,  315,  315,  315,
 708       332,  362,  362,  362,  332,  362,  362,  362,  332,  332,
 709         7,  362,  362,  362,  362,  362,  362,  362,  362,  362,
 710       362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
 711       362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
 712
 713       362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
 714       362,  362,  362,  362,  362,  362,  362,  362,  362
 715     } ;
 716
 717 static yyconst short int yy_chk[1820] =
 718     {   0,
 719         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 720         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 721         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 722         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 723         1,    1,    1,    1,    1,    1,    1,    1,    3,    3,
 724         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 725         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 726         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 727         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 728         3,    3,    3,    3,    3,    3,    5,    6,   35,  371,
 729
 730         5,    6,   11,   12,  371,   39,   11,   11,   35,   11,
 731        35,   11,   31,  350,   12,   12,   11,   11,   11,   33,
 732        31,   32,   31,   11,   91,   32,   39,   38,   91,   33,
 733        33,   32,   73,   11,   11,   11,   11,   38,   38,   73,
 734       344,   11,   14,   14,   14,   14,   14,   14,   14,   14,
 735        14,   14,   14,   14,   14,   14,   14,   14,   14,   14,
 736        14,   14,   14,   14,   14,   14,   14,   14,   14,   14,
 737        14,   14,   14,   14,   14,   14,   14,   14,   14,   14,
 738        14,   14,   14,   14,   14,   14,   14,   14,   14,   14,
 739        20,   20,   20,   36,   22,   63,   36,  372,   61,   40,
 740
 741        23,   63,  372,   36,   22,   20,   22,   22,   61,   37,
 742        23,   20,   23,   23,  337,   37,   22,  336,   20,   37,
 743        40,   22,   23,   29,   29,   29,   34,   23,   43,   34,
 744       335,   29,   45,   46,   48,   22,   34,   34,   29,   47,
 745        49,   34,   29,   30,   30,   30,   47,   51,   54,   43,
 746        49,   30,   56,   45,   46,   48,   57,   58,   30,   59,
 747        47,   49,   30,   74,  332,   51,   54,   65,   51,   54,
 748       331,   56,   30,   56,   57,   65,  328,   57,   58,   65,
 749        59,   74,   30,   42,   42,   42,   42,   42,   42,   42,
 750        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
 751
 752        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
 753        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
 754        42,   42,   42,   42,   42,   42,   42,   42,   44,   44,
 755        44,   44,   44,   44,   44,   44,   44,   44,   44,   44,
 756        44,   44,   44,   44,   44,   44,   44,   44,   44,   44,
 757        44,   44,   44,   44,   44,   44,   44,   44,   44,   44,
 758        44,   44,   44,   44,   44,   44,   44,   44,   44,   44,
 759        44,   44,   44,   44,   44,   44,   50,   50,   50,   50,
 760        50,   50,   50,   50,   50,   50,   50,   50,   50,   50,
 761        50,   50,   50,   50,   50,   50,   50,   50,   50,   50,
 762
 763        50,   50,   50,   50,   50,   50,   50,   50,   50,   50,
 764        50,   50,   50,   50,   50,   50,   50,   50,   50,   50,
 765        50,   50,   50,   52,   52,   75,  267,   76,   77,   83,
 766        83,   84,   84,  267,   52,  130,   52,   52,   77,  102,
 767       102,  325,  104,   75,   52,   76,   52,  104,  104,  115,
 768       117,   52,  118,  264,  118,  264,  130,  186,  186,  115,
 769       117,  319,  118,  117,  318,   52,   55,   55,   55,   55,
 770        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
 771        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
 772        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
 773
 774        55,   55,   55,   55,   55,   55,   55,   55,   55,   55,
 775        55,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 776        60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 777        60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 778        60,   60,   60,   60,   60,   60,   60,   60,   60,   60,
 779        60,   60,   60,   60,   60,   60,   60,   60,   71,   71,
 780        71,   71,   71,   71,   71,   71,   71,  317,   71,   71,
 781        71,   71,   71,   71,   71,   71,   71,   71,   71,   71,
 782        71,   71,   71,   71,   71,   71,   71,   71,   71,   71,
 783        71,   71,   71,   71,   71,   71,   71,   71,   71,   71,
 784
 785        71,   71,   71,   71,   71,   71,   86,   86,   86,  111,
 786       111,  111,  119,  120,   86,  315,  121,  122,  314,  122,
 787       126,  125,  119,  120,  111,  119,  121,  122,  111,  125,
 788       126,  125,  198,  198,   86,   86,   86,   86,   86,   86,
 789        86,   86,   86,   86,   86,   86,   86,   86,   86,   86,
 790        86,   86,   86,   92,  123,  124,  313,  127,  128,  312,
 791       133,  128,  307,  307,  123,  124,  127,  127,  128,  124,
 792       123,  133,  133,   92,   92,   92,   92,   92,   92,   92,
 793        92,   92,   92,   92,   92,   92,   92,   92,   92,   92,
 794        92,   92,   95,   95,   95,  311,  103,  112,  112,  112,
 795
 796       114,  114,  114,  310,  114,  112,  103,   95,  103,  103,
 797       132,  309,  112,   95,  129,  141,  112,  135,  103,  306,
 798        95,  114,  144,  103,  129,  148,  129,  304,  135,  135,
 799       297,  132,  137,  137,  137,  150,  141,  152,  154,  346,
 800       137,  346,  196,  144,  208,  152,  148,  209,  150,  150,
 801       152,  152,  196,  296,  208,  284,  150,  209,  152,  154,
 802       137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
 803       137,  137,  137,  137,  137,  137,  137,  137,  137,  140,
 804       140,  140,  140,  140,  140,  140,  140,  140,  140,  140,
 805       140,  140,  140,  140,  140,  140,  140,  140,  142,  142,
 806
 807       155,  157,  158,  142,  211,  161,  179,  179,  179,  187,
 808       187,  187,  329,  329,  211,  179,  277,  199,  199,  212,
 809       276,  155,  157,  158,  142,  145,  161,  199,  187,  212,
 810       145,  145,  145,  145,  145,  145,  145,  145,  145,  145,
 811       145,  145,  145,  145,  145,  145,  145,  145,  145,  145,
 812       146,  146,  305,  355,  355,  275,  274,  305,  305,  273,
 813       146,  146,  146,  146,  146,  146,  146,  146,  146,  146,
 814       146,  146,  146,  146,  146,  146,  146,  146,  146,  146,
 815       149,  164,  197,  197,  188,  188,  188,  272,  210,  213,
 816       215,  210,  197,  149,  149,  241,  164,  197,  210,  213,
 817
 818       215,  149,  164,  188,  149,  149,  149,  149,  149,  149,
 819       153,  153,  381,  382,  266,  260,  241,  381,  382,  257,
 820       255,  153,  153,  153,  153,  153,  153,  156,  156,  156,
 821       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
 822       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
 823       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
 824       156,  156,  156,  156,  156,  156,  156,  156,  156,  156,
 825       156,  156,  160,  160,  160,  250,  160,  202,  202,  202,
 826       160,  248,  244,  216,  217,  202,  235,  160,  227,  201,
 827       195,  160,  202,  216,  217,  193,  202,  160,  162,  162,
 828
 829       162,  162,  162,  162,  162,  162,  162,  162,  162,  162,
 830       162,  162,  162,  162,  162,  162,  162,  162,  162,  162,
 831       162,  162,  162,  162,  162,  162,  162,  162,  162,  162,
 832       162,  162,  162,  162,  162,  162,  162,  162,  162,  162,
 833       162,  162,  162,  162,  162,  190,  190,  203,  203,  203,
 834       191,  203,  185,  268,  218,  184,  190,  190,  190,  190,
 835       190,  190,  206,  206,  206,  218,  218,  183,  203,  204,
 836       206,  268,  214,  204,  204,  182,  204,  206,  204,  181,
 837       214,  206,  214,  204,  204,  204,  180,  219,  219,  219,
 838       204,  219,  222,  222,  224,  224,  229,  222,  269,  224,
 839
 840       204,  204,  204,  204,  262,  178,  219,  270,  204,  229,
 841       229,  288,  219,  220,  262,  230,  269,  229,  222,  229,
 842       224,  252,  252,  252,  229,  270,  220,  220,  230,  230,
 843       252,  177,  288,  176,  175,  173,  230,  220,  220,  220,
 844       220,  220,  220,  225,  225,  225,  225,  225,  225,  225,
 845       225,  225,  225,  225,  225,  225,  225,  225,  225,  225,
 846       225,  225,  225,  225,  225,  225,  225,  225,  225,  225,
 847       225,  225,  225,  225,  225,  225,  225,  225,  225,  225,
 848       225,  225,  225,  225,  225,  225,  225,  225,  228,  254,
 849       254,  254,  263,  263,  172,  265,  265,  171,  228,  271,
 850
 851       228,  228,  263,  316,  231,  265,  170,  263,  254,  271,
 852       228,  228,  228,  228,  228,  228,  228,  231,  231,  167,
 853       279,  280,  281,  166,  316,  231,  165,  231,  232,  232,
 854       279,  280,  281,  283,  290,  159,  151,  147,  143,  232,
 855       232,  232,  232,  232,  232,  234,  234,  234,  283,  234,
 856       278,  278,  278,  234,  283,  290,  330,  330,  278,  139,
 857       234,  136,  290,  134,  234,  278,  330,  116,  108,  278,
 858       234,  239,  239,  239,  239,  239,  239,  239,  239,  239,
 859       239,  239,  239,  239,  239,  239,  239,  239,  239,  239,
 860       239,  240,  240,   99,   90,   89,   88,   87,   82,   81,
 861
 862        80,  240,  240,  240,  240,  240,  240,  240,  240,  240,
 863       240,  240,  240,  240,  240,  240,  240,  240,  240,  240,
 864       240,  256,  256,  282,  282,  282,   79,  282,  333,  333,
 865       293,  294,  256,  256,  256,  256,  256,  256,  333,  294,
 866        78,  294,  282,  293,  293,   72,  345,  345,  282,  285,
 867       285,  293,  294,  293,  295,  340,  345,   69,  293,   68,
 868       285,  285,  285,  285,  285,  285,  286,  295,  295,   67,
 869       308,  308,  308,   66,   64,  295,  340,  295,  308,  286,
 870       286,   62,   53,  340,   27,  308,  354,  354,  354,  308,
 871       286,  286,  286,  286,  286,  286,  291,  291,   26,   25,
 872
 873        24,   21,   19,   17,    7,  354,    0,  291,  291,  291,
 874       291,  291,  291,  298,  298,  298,  298,  298,  298,  298,
 875       298,  298,  298,  298,  298,  298,  298,  298,  298,  298,
 876       298,  298,  298,  298,  298,  298,  298,  298,  298,  298,
 877       298,  298,  298,  298,  298,  298,  298,  298,  298,  298,
 878       298,  298,  298,  298,  298,  298,  298,  298,  320,  320,
 879         0,    0,    0,  323,    0,  338,    0,  321,    0,  320,
 880       320,  320,  320,  320,  320,  321,  323,  323,  338,  338,
 881       321,  321,  339,    0,  323,  342,  338,    0,  321,  322,
 882       347,  347,    0,    0,    0,  339,  339,    0,  342,  342,
 883
 884       347,  322,  322,  339,    0,  339,  342,    0,  342,    0,
 885       357,  322,  322,  322,  322,  322,  322,  322,  327,  327,
 886       327,  351,  327,  357,  357,    0,  327,  353,  352,  358,
 887       358,  357,  359,  327,  351,  351,  352,  327,  352,  358,
 888       353,  353,  351,  327,  351,  359,  359,    0,  353,  352,
 889       353,  360,  360,  359,  361,  359,    0,    0,    0,    0,
 890         0,  360,    0,    0,    0,    0,    0,  361,  361,    0,
 891         0,    0,    0,    0,    0,  361,    0,  361,  363,    0,
 892         0,  363,    0,    0,    0,  363,  363,  363,  364,  364,
 893       364,    0,    0,    0,    0,    0,  364,    0,  364,    0,
 894
 895         0,  364,  364,  364,  365,    0,  365,  365,  365,  366,
 896       366,  366,    0,    0,    0,    0,  366,  366,  366,    0,
 897         0,    0,  366,  366,  366,  367,  367,  367,  367,  367,
 898       367,  367,  367,  367,  367,  367,  367,  367,  367,  368,
 899       368,    0,  368,  368,  368,  368,  368,  368,  368,  368,
 900       368,  368,  368,  368,  368,  368,  369,  369,  369,  370,
 901         0,    0,    0,  370,  370,  370,  373,    0,    0,  373,
 902       373,  373,  373,  374,  374,  374,    0,  374,    0,    0,
 903         0,    0,    0,  374,    0,    0,  374,  374,  374,  375,
 904       375,    0,  375,  375,  375,  375,  375,  375,  375,  375,
 905
 906       375,  375,  375,  375,  375,  375,  376,    0,    0,    0,
 907         0,  376,    0,    0,    0,    0,  376,  377,    0,    0,
 908       377,  377,  377,  377,  378,    0,    0,  378,  378,    0,
 909         0,    0,  378,  378,  379,  379,  379,  380,  380,  380,
 910         0,    0,    0,    0,  380,  380,  380,    0,    0,    0,
 911       380,  380,  380,  383,    0,    0,  383,  383,  383,  383,
 912       384,    0,    0,    0,  384,    0,    0,    0,  384,  384,
 913       362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
 914       362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
 915       362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
 916
 917       362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
 918       362,  362,  362,  362,  362,  362,  362,  362,  362
 919     } ;
 920
 921 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
 922 static char *yy_full_match;
 923 static int yy_lp;
 924 static int yy_looking_for_trail_begin = 0;
 925 static int yy_full_lp;
 926 static int *yy_full_state;
 927 #define YY_TRAILING_MASK 0x2000
 928 #define YY_TRAILING_HEAD_MASK 0x4000
 929 #define REJECT \
 930 { \
 931 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
 932 yy_cp = yy_full_match; /* restore poss. backed-over text */ \
 933 yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \
 934 yy_state_ptr = yy_full_state; /* restore orig. state */ \
 935 yy_current_state = *yy_state_ptr; /* restore curr. state */ \
 936 ++yy_lp; \
 937 goto find_rule; \
 938 }
 939 #define yymore() yymore_used_but_not_detected
 940 #define YY_MORE_ADJ 0
 941 #define YY_RESTORE_YY_MORE_OFFSET
 942 char *yytext;
 943 #line 1 "./ada-lex.l"
 944 #define INITIAL 0
 945 /* FLEX lexer for Ada expressions, for GDB.
 946    Copyright (C) 1994, 1997, 2000
 947    Free Software Foundation, Inc.
 948
 949 This file is part of GDB.
 950
 951 This program is free software; you can redistribute it and/or modify
 952 it under the terms of the GNU General Public License as published by
 953 the Free Software Foundation; either version 2 of the License, or
 954 (at your option) any later version.
 955
 956 This program is distributed in the hope that it will be useful,
 957 but WITHOUT ANY WARRANTY; without even the implied warranty of
 958 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 959 GNU General Public License for more details.
 960
 961 You should have received a copy of the GNU General Public License
 962 along with this program; if not, write to the Free Software
 963 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 964 /*----------------------------------------------------------------------*/
 965 /* The converted version of this file is to be included in ada-exp.y, */
 966 /* the Ada parser for gdb.  The function yylex obtains characters from */
 967 /* the global pointer lexptr.  It returns a syntactic category for */
 968 /* each successive token and places a semantic value into yylval */
 969 /* (ada-lval), defined by the parser.   */
 970 /* Run flex with (at least) the -i option (case-insensitive), and the -I */
 971 /* option (interactive---no unnecessary lookahead).  */
 972 #line 48 "./ada-lex.l"
 973 #define NUMERAL_WIDTH 256
 974 #define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
 975
 976 /* Temporary staging for numeric literals. */
 977 static char numbuf[NUMERAL_WIDTH];
 978  static void canonicalizeNumeral (char* s1, const char*);
 979 static int processInt (const char*, const char*, const char*);
 980 static int processReal (const char*);
 981 static int processId (const char*, int);
 982 static int processAttribute (const char*);
 983 static int find_dot_all (const char*);
 984
 985 #undef YY_DECL
 986 #define YY_DECL static int yylex ( void )
 987
 988 #undef YY_INPUT
 989 #define YY_INPUT(BUF, RESULT, MAX_SIZE) \
 990     if ( *lexptr == '\000' ) \
 991       (RESULT) = YY_NULL; \
 992     else \
 993       { \
 994         *(BUF) = *lexptr; \
 995         (RESULT) = 1; \
 996         lexptr += 1; \
 997       }
 998
 999 static char *tempbuf = NULL;
1000 static int tempbufsize = 0;
1001 static int tempbuf_len;
1002 static struct block* left_block_context;
1003
1004 static void resize_tempbuf (unsigned int);
1005
1006 static void block_lookup (char*, char*);
1007
1008 static int name_lookup (char*, char*, int*);
1009
1010 static int find_dot_all (const char*);
1011
1012 #define IN_STRING 1
1013 #define BEFORE_QUAL_QUOTE 2
1014
1015
1016 /* Macros after this point can all be overridden by user definitions in
1017  * section 1.
1018  */
1019
1020 #ifndef YY_SKIP_YYWRAP
1021 #ifdef __cplusplus
1022 extern "C" int yywrap YY_PROTO(( void ));
1023 #else
1024 extern int yywrap YY_PROTO(( void ));
1025 #endif
1026 #endif
1027
1028 #ifndef YY_NO_UNPUT
1029 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
1030 #endif
1031
1032 #ifndef yytext_ptr
1033 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
1034 #endif
1035
1036 #ifdef YY_NEED_STRLEN
1037 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
1038 #endif
1039
1040 #ifndef YY_NO_INPUT
1041 #ifdef __cplusplus
1042 static int yyinput YY_PROTO(( void ));
1043 #else
1044 static int input YY_PROTO(( void ));
1045 #endif
1046 #endif
1047
1048 #if YY_STACK_USED
1049 static int yy_start_stack_ptr = 0;
1050 static int yy_start_stack_depth = 0;
1051 static int *yy_start_stack = 0;
1052 #ifndef YY_NO_PUSH_STATE
1053 static void yy_push_state YY_PROTO(( int new_state ));
1054 #endif
1055 #ifndef YY_NO_POP_STATE
1056 static void yy_pop_state YY_PROTO(( void ));
1057 #endif
1058 #ifndef YY_NO_TOP_STATE
1059 static int yy_top_state YY_PROTO(( void ));
1060 #endif
1061
1062 #else
1063 #define YY_NO_PUSH_STATE 1
1064 #define YY_NO_POP_STATE 1
1065 #define YY_NO_TOP_STATE 1
1066 #endif
1067
1068 #ifdef YY_MALLOC_DECL
1069 YY_MALLOC_DECL
1070 #else
1071 #if __STDC__
1072 #ifndef __cplusplus
1073 #include <stdlib.h>
1074 #endif
1075 #else
1076 /* Just try to get by without declaring the routines.  This will fail
1077  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
1078  * or sizeof(void*) != sizeof(int).
1079  */
1080 #endif
1081 #endif
1082
1083 /* Amount of stuff to slurp up with each read. */
1084 #ifndef YY_READ_BUF_SIZE
1085 #define YY_READ_BUF_SIZE 8192
1086 #endif
1087
1088 /* Copy whatever the last rule matched to the standard output. */
1089
1090 #ifndef ECHO
1091 /* This used to be an fputs(), but since the string might contain NUL's,
1092  * we now use fwrite().
1093  */
1094 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1095 #endif
1096
1097 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1098  * is returned in "result".
1099  */
1100 #ifndef YY_INPUT
1101 #define YY_INPUT(buf,result,max_size) \
1102         if ( yy_current_buffer->yy_is_interactive ) \
1103                 { \
1104                 int c = '*', n; \
1105                 for ( n = 0; n < max_size && \
1106                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1107                         buf[n] = (char) c; \
1108                 if ( c == '\n' ) \
1109                         buf[n++] = (char) c; \
1110                 if ( c == EOF && ferror( yyin ) ) \
1111                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1112                 result = n; \
1113                 } \
1114         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1115                   && ferror( yyin ) ) \
1116                 YY_FATAL_ERROR( "input in flex scanner failed" );
1117 #endif
1118
1119 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1120  * we don't want an extra ';' after the "return" because that will cause
1121  * some compilers to complain about unreachable statements.
1122  */
1123 #ifndef yyterminate
1124 #define yyterminate() return YY_NULL
1125 #endif
1126
1127 /* Number of entries by which start-condition stack grows. */
1128 #ifndef YY_START_STACK_INCR
1129 #define YY_START_STACK_INCR 25
1130 #endif
1131
1132 /* Report a fatal error. */
1133 #ifndef YY_FATAL_ERROR
1134 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1135 #endif
1136
1137 /* Default declaration of generated scanner - a define so the user can
1138  * easily add parameters.
1139  */
1140 #ifndef YY_DECL
1141 #define YY_DECL int yylex YY_PROTO(( void ))
1142 #endif
1143
1144 /* Code executed at the beginning of each rule, after yytext and yyleng
1145  * have been set up.
1146  */
1147 #ifndef YY_USER_ACTION
1148 #define YY_USER_ACTION
1149 #endif
1150
1151 /* Code executed at the end of each rule. */
1152 #ifndef YY_BREAK
1153 #define YY_BREAK break;
1154 #endif
1155
1156 #define YY_RULE_SETUP \
1157         YY_USER_ACTION
1158
1159 YY_DECL
1160         {
1161         register yy_state_type yy_current_state;
1162         register char *yy_cp, *yy_bp;
1163         register int yy_act;
1164
1165 #line 91 "./ada-lex.l"
1166
1167
1168
1169         if ( yy_init )
1170                 {
1171                 yy_init = 0;
1172
1173 #ifdef YY_USER_INIT
1174                 YY_USER_INIT;
1175 #endif
1176
1177                 if ( ! yy_start )
1178                         yy_start = 1;   /* first start state */
1179
1180                 if ( ! yyin )
1181                         yyin = stdin;
1182
1183                 if ( ! yyout )
1184                         yyout = stdout;
1185
1186                 if ( ! yy_current_buffer )
1187                         yy_current_buffer =
1188                                 yy_create_buffer( yyin, YY_BUF_SIZE );
1189
1190                 yy_load_buffer_state();
1191                 }
1192
1193         while ( 1 )             /* loops until end-of-file is reached */
1194                 {
1195                 yy_cp = yy_c_buf_p;
1196
1197                 /* Support of yytext. */
1198                 *yy_cp = yy_hold_char;
1199
1200                 /* yy_bp points to the position in yy_ch_buf of the start of
1201                  * the current run.
1202                  */
1203                 yy_bp = yy_cp;
1204
1205                 yy_current_state = yy_start;
1206                 yy_state_ptr = yy_state_buf;
1207                 *yy_state_ptr++ = yy_current_state;
1208 yy_match:
1209                 do
1210                         {
1211                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1212                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1213                                 {
1214                                 yy_current_state = (int) yy_def[yy_current_state];
1215                                 if ( yy_current_state >= 363 )
1216                                         yy_c = yy_meta[(unsigned int) yy_c];
1217                                 }
1218                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1219                         *yy_state_ptr++ = yy_current_state;
1220                         ++yy_cp;
1221                         }
1222                 while ( yy_base[yy_current_state] != 1771 );
1223
1224 yy_find_action:
1225                 yy_current_state = *--yy_state_ptr;
1226                 yy_lp = yy_accept[yy_current_state];
1227 find_rule: /* we branch to this label when backing up */
1228                 for ( ; ; ) /* until we find what rule we matched */
1229                         {
1230                         if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
1231                                 {
1232                                 yy_act = yy_acclist[yy_lp];
1233                                 if ( yy_act & YY_TRAILING_HEAD_MASK ||
1234                                      yy_looking_for_trail_begin )
1235                                         {
1236                                         if ( yy_act == yy_looking_for_trail_begin )
1237                                                 {
1238                                                 yy_looking_for_trail_begin = 0;
1239                                                 yy_act &= ~YY_TRAILING_HEAD_MASK;
1240                                                 break;
1241                                                 }
1242                                         }
1243                                 else if ( yy_act & YY_TRAILING_MASK )
1244                                         {
1245                                         yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;
1246                                         yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;
1247                                         }
1248                                 else
1249                                         {
1250                                         yy_full_match = yy_cp;
1251                                         yy_full_state = yy_state_ptr;
1252                                         yy_full_lp = yy_lp;
1253                                         break;
1254                                         }
1255                                 ++yy_lp;
1256                                 goto find_rule;
1257                                 }
1258                         --yy_cp;
1259                         yy_current_state = *--yy_state_ptr;
1260                         yy_lp = yy_accept[yy_current_state];
1261                         }
1262
1263                 YY_DO_BEFORE_ACTION;
1264
1265
1266 do_action:      /* This label is used only to access EOF actions. */
1267
1268
1269                 switch ( yy_act )
1270         { /* beginning of action switch */
1271 case 1:
1272 YY_RULE_SETUP
1273 #line 93 "./ada-lex.l"
1274 { }
1275         YY_BREAK
1276 case 2:
1277 YY_RULE_SETUP
1278 #line 95 "./ada-lex.l"
1279 { yyterminate(); }
1280         YY_BREAK
1281 case 3:
1282 YY_RULE_SETUP
1283 #line 97 "./ada-lex.l"
1284 {
1285                    canonicalizeNumeral (numbuf, yytext);
1286                    return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1);
1287                  }
1288         YY_BREAK
1289 case 4:
1290 YY_RULE_SETUP
1291 #line 102 "./ada-lex.l"
1292 {
1293                    canonicalizeNumeral (numbuf, yytext);
1294                    return processInt (NULL, numbuf, NULL);
1295                  }
1296         YY_BREAK
1297 case 5:
1298 YY_RULE_SETUP
1299 #line 107 "./ada-lex.l"
1300 {
1301                    canonicalizeNumeral (numbuf, yytext);
1302                    return processInt (numbuf,
1303                                       strchr (numbuf, '#') + 1,
1304                                       strrchr(numbuf, '#') + 1);
1305                  }
1306         YY_BREAK
1307 case 6:
1308 YY_RULE_SETUP
1309 #line 114 "./ada-lex.l"
1310 {
1311                    canonicalizeNumeral (numbuf, yytext);
1312                    return processInt (numbuf, strchr (numbuf, '#') + 1, NULL);
1313                  }
1314         YY_BREAK
1315 case 7:
1316 YY_RULE_SETUP
1317 #line 119 "./ada-lex.l"
1318 {
1319                   canonicalizeNumeral (numbuf, yytext+2);
1320                   return processInt ("16#", numbuf, NULL);
1321                 }
1322         YY_BREAK
1323 case 8:
1324 YY_RULE_SETUP
1325 #line 125 "./ada-lex.l"
1326 {
1327                    canonicalizeNumeral (numbuf, yytext);
1328                    return processReal (numbuf);
1329                 }
1330         YY_BREAK
1331 case 9:
1332 YY_RULE_SETUP
1333 #line 130 "./ada-lex.l"
1334 {
1335                    canonicalizeNumeral (numbuf, yytext);
1336                    return processReal (numbuf);
1337                 }
1338         YY_BREAK
1339 case 10:
1340 YY_RULE_SETUP
1341 #line 135 "./ada-lex.l"
1342 {
1343                    error ("Based real literals not implemented yet.");
1344                 }
1345         YY_BREAK
1346 case 11:
1347 YY_RULE_SETUP
1348 #line 139 "./ada-lex.l"
1349 {
1350                    error ("Based real literals not implemented yet.");
1351                 }
1352         YY_BREAK
1353 case 12:
1354 YY_RULE_SETUP
1355 #line 143 "./ada-lex.l"
1356 {
1357                    yylval.typed_val.type = builtin_type_ada_char;
1358                    yylval.typed_val.val = yytext[1];
1359                    return CHARLIT;
1360                 }
1361         YY_BREAK
1362 case 13:
1363 YY_RULE_SETUP
1364 #line 149 "./ada-lex.l"
1365 {
1366                    int v;
1367                    yylval.typed_val.type = builtin_type_ada_char;
1368                    sscanf (yytext+3, "%2x", &v);
1369                    yylval.typed_val.val = v;
1370                    return CHARLIT;
1371                 }
1372         YY_BREAK
1373 case 14:
1374 YY_RULE_SETUP
1375 #line 157 "./ada-lex.l"
1376 { return processId (yytext, yyleng); }
1377         YY_BREAK
1378 case 15:
1379 YY_RULE_SETUP
1380 #line 159 "./ada-lex.l"
1381 {
1382                    tempbuf_len = 0;
1383                    BEGIN IN_STRING;
1384                 }
1385         YY_BREAK
1386 case 16:
1387 YY_RULE_SETUP
1388 #line 164 "./ada-lex.l"
1389 {
1390                    resize_tempbuf (yyleng+tempbuf_len);
1391                    strncpy (tempbuf+tempbuf_len, yytext, yyleng-1);
1392                    tempbuf_len += yyleng-1;
1393                    yylval.sval.ptr = tempbuf;
1394                    yylval.sval.length = tempbuf_len;
1395                    BEGIN INITIAL;
1396                    return STRING;
1397                 }
1398         YY_BREAK
1399 case 17:
1400 YY_RULE_SETUP
1401 #line 174 "./ada-lex.l"
1402 {
1403                    int n;
1404                    resize_tempbuf (yyleng-5+tempbuf_len+1);
1405                    strncpy (tempbuf+tempbuf_len, yytext, yyleng-6);
1406                    sscanf(yytext+yyleng-4, "%2x", &n);
1407                    tempbuf[yyleng-6+tempbuf_len] = (char) n;
1408                    tempbuf_len += yyleng-5;
1409                 }
1410         YY_BREAK
1411 case 18:
1412 YY_RULE_SETUP
1413 #line 183 "./ada-lex.l"
1414 {
1415                    int n;
1416                    resize_tempbuf (yyleng-4+tempbuf_len+1);
1417                    strncpy (tempbuf+tempbuf_len, yytext, yyleng-6);
1418                    tempbuf[yyleng-5+tempbuf_len] = '"';
1419                    tempbuf_len += yyleng-4;
1420                 }
1421         YY_BREAK
1422 case 19:
1423 YY_RULE_SETUP
1424 #line 191 "./ada-lex.l"
1425 {
1426                   while (*lexptr != 'i' && *lexptr != 'I')
1427                     lexptr -= 1;
1428                   yyrestart(NULL);
1429                   return 0;
1430                 }
1431         YY_BREAK
1432 /* ADA KEYWORDS */
1433 case 20:
1434 YY_RULE_SETUP
1435 #line 200 "./ada-lex.l"
1436 { return ABS; }
1437         YY_BREAK
1438 case 21:
1439 YY_RULE_SETUP
1440 #line 201 "./ada-lex.l"
1441 { return _AND_; }
1442         YY_BREAK
1443 case 22:
1444 YY_RULE_SETUP
1445 #line 202 "./ada-lex.l"
1446 { return ELSE; }
1447         YY_BREAK
1448 case 23:
1449 YY_RULE_SETUP
1450 #line 203 "./ada-lex.l"
1451 { return IN; }
1452         YY_BREAK
1453 case 24:
1454 YY_RULE_SETUP
1455 #line 204 "./ada-lex.l"
1456 { return MOD; }
1457         YY_BREAK
1458 case 25:
1459 YY_RULE_SETUP
1460 #line 205 "./ada-lex.l"
1461 { return NEW; }
1462         YY_BREAK
1463 case 26:
1464 YY_RULE_SETUP
1465 #line 206 "./ada-lex.l"
1466 { return NOT; }
1467         YY_BREAK
1468 case 27:
1469 YY_RULE_SETUP
1470 #line 207 "./ada-lex.l"
1471 { return NULL_PTR; }
1472         YY_BREAK
1473 case 28:
1474 YY_RULE_SETUP
1475 #line 208 "./ada-lex.l"
1476 { return OR; }
1477         YY_BREAK
1478 case 29:
1479 YY_RULE_SETUP
1480 #line 209 "./ada-lex.l"
1481 { return REM; }
1482         YY_BREAK
1483 case 30:
1484 YY_RULE_SETUP
1485 #line 210 "./ada-lex.l"
1486 { return THEN; }
1487         YY_BREAK
1488 case 31:
1489 YY_RULE_SETUP
1490 #line 211 "./ada-lex.l"
1491 { return XOR; }
1492         YY_BREAK
1493 /* ATTRIBUTES */
1494 case 32:
1495 YY_RULE_SETUP
1496 #line 215 "./ada-lex.l"
1497 { return processAttribute (yytext+1); }
1498         YY_BREAK
1499 /* PUNCTUATION */
1500 case 33:
1501 YY_RULE_SETUP
1502 #line 219 "./ada-lex.l"
1503 { return ARROW; }
1504         YY_BREAK
1505 case 34:
1506 YY_RULE_SETUP
1507 #line 220 "./ada-lex.l"
1508 { return DOTDOT; }
1509         YY_BREAK
1510 case 35:
1511 YY_RULE_SETUP
1512 #line 221 "./ada-lex.l"
1513 { return STARSTAR; }
1514         YY_BREAK
1515 case 36:
1516 YY_RULE_SETUP
1517 #line 222 "./ada-lex.l"
1518 { return ASSIGN; }
1519         YY_BREAK
1520 case 37:
1521 YY_RULE_SETUP
1522 #line 223 "./ada-lex.l"
1523 { return NOTEQUAL; }
1524         YY_BREAK
1525 case 38:
1526 YY_RULE_SETUP
1527 #line 224 "./ada-lex.l"
1528 { return LEQ; }
1529         YY_BREAK
1530 case 39:
1531 YY_RULE_SETUP
1532 #line 225 "./ada-lex.l"
1533 { return GEQ; }
1534         YY_BREAK
1535 case 40:
1536 YY_RULE_SETUP
1537 #line 227 "./ada-lex.l"
1538 { BEGIN INITIAL; return '\''; }
1539         YY_BREAK
1540 case 41:
1541 YY_RULE_SETUP
1542 #line 229 "./ada-lex.l"
1543 { return yytext[0]; }
1544         YY_BREAK
1545 case 42:
1546 YY_RULE_SETUP
1547 #line 231 "./ada-lex.l"
1548 { if (paren_depth == 0 && comma_terminates)
1549                     {
1550                       lexptr -= 1;
1551                       yyrestart(NULL);
1552                       return 0;
1553                     }
1554                   else
1555                     return ',';
1556                 }
1557         YY_BREAK
1558 case 43:
1559 YY_RULE_SETUP
1560 #line 241 "./ada-lex.l"
1561 { paren_depth += 1; return '('; }
1562         YY_BREAK
1563 case 44:
1564 YY_RULE_SETUP
1565 #line 242 "./ada-lex.l"
1566 { if (paren_depth == 0)
1567                     {
1568                       lexptr -= 1;
1569                       yyrestart(NULL);
1570                       return 0;
1571                     }
1572                   else
1573                     {
1574                       paren_depth -= 1;
1575                       return ')';
1576                     }
1577                 }
1578         YY_BREAK
1579 case 45:
1580 YY_RULE_SETUP
1581 #line 255 "./ada-lex.l"
1582 { return DOT_ALL; }
1583         YY_BREAK
1584 case 46:
1585 YY_RULE_SETUP
1586 #line 257 "./ada-lex.l"
1587 {
1588                   processId (yytext+1, yyleng-1);
1589                   return DOT_ID;
1590                 }
1591         YY_BREAK
1592 case 47:
1593 YY_RULE_SETUP
1594 #line 262 "./ada-lex.l"
1595 {
1596                   int all_posn = find_dot_all (yytext);
1597                   int token_type, segments, k;
1598                   int quote_follows;
1599
1600                   if (all_posn == -1 && yytext[yyleng-1] == '\'')
1601                     {
1602                       quote_follows = 1;
1603                       do {
1604                         yyless (yyleng-1);
1605                       } while (yytext[yyleng-1] == ' ');
1606                     }
1607                   else
1608                     quote_follows = 0;
1609
1610                   if (all_posn >= 0)
1611                     yyless (all_posn);
1612                   processId(yytext, yyleng);
1613                   segments = name_lookup (ada_mangle (yylval.ssym.stoken.ptr),
1614                                           yylval.ssym.stoken.ptr, &token_type);
1615                   left_block_context = NULL;
1616                   for (k = yyleng; segments > 0 && k > 0; k -= 1)
1617                     {
1618                       if (yytext[k-1] == '.')
1619                         segments -= 1;
1620                       quote_follows = 0;
1621                     }
1622                   if (k <= 0)
1623                     error ("confused by name %s", yytext);
1624                   yyless (k);
1625                   if (quote_follows)
1626                     BEGIN BEFORE_QUAL_QUOTE;
1627                   return token_type;
1628                 }
1629         YY_BREAK
1630 /* GDB EXPRESSION CONSTRUCTS  */
1631 case 48:
1632 YY_RULE_SETUP
1633 #line 300 "./ada-lex.l"
1634 {
1635                   processId(yytext, yyleng-2);
1636                   block_lookup (yylval.ssym.stoken.ptr, yylval.ssym.stoken.ptr);
1637                   return BLOCKNAME;
1638                 }
1639         YY_BREAK
1640 case 49:
1641 YY_RULE_SETUP
1642 #line 306 "./ada-lex.l"
1643 {
1644                   processId(yytext, yyleng-2);
1645                   block_lookup (ada_mangle (yylval.ssym.stoken.ptr),
1646                                 yylval.ssym.stoken.ptr);
1647                   return BLOCKNAME;
1648                 }
1649         YY_BREAK
1650 case 50:
1651 YY_RULE_SETUP
1652 #line 313 "./ada-lex.l"
1653 { return yytext[0]; }
1654         YY_BREAK
1655 case 51:
1656 YY_RULE_SETUP
1657 #line 315 "./ada-lex.l"
1658 { yylval.lval = -1; return LAST; }
1659         YY_BREAK
1660 case 52:
1661 YY_RULE_SETUP
1662 #line 316 "./ada-lex.l"
1663 { yylval.lval = -atoi(yytext+2); return LAST; }
1664         YY_BREAK
1665 case 53:
1666 YY_RULE_SETUP
1667 #line 317 "./ada-lex.l"
1668 { yylval.lval = 0; return LAST; }
1669         YY_BREAK
1670 case 54:
1671 YY_RULE_SETUP
1672 #line 318 "./ada-lex.l"
1673 { yylval.lval = atoi(yytext+1); return LAST; }
1674         YY_BREAK
1675 /* REGISTERS AND GDB CONVENIENCE VARIABLES */
1676 case 55:
1677 YY_RULE_SETUP
1678 #line 323 "./ada-lex.l"
1679 {
1680                   int c;
1681                   for (c = 0; c < NUM_REGS; c++)
1682                     if (REGISTER_NAME (c) &&
1683                         strcmp (yytext + 1, REGISTER_NAME (c)) == 0)
1684                       {
1685                         yylval.lval = c;
1686                         return REGNAME;
1687                       }
1688                   yylval.sval.ptr = yytext;
1689                   yylval.sval.length = yyleng;
1690                   yylval.ivar =
1691                     lookup_internalvar (copy_name (yylval.sval) + 1);
1692                   return INTERNAL_VARIABLE;
1693                 }
1694         YY_BREAK
1695 /* CATCH-ALL ERROR CASE */
1696 case 56:
1697 YY_RULE_SETUP
1698 #line 341 "./ada-lex.l"
1699 { error ("Invalid character '%s' in expression.", yytext); }
1700         YY_BREAK
1701 case 57:
1702 YY_RULE_SETUP
1703 #line 342 "./ada-lex.l"
1704 YY_FATAL_ERROR( "flex scanner jammed" );
1705         YY_BREAK
1706                         case YY_STATE_EOF(INITIAL):
1707                         case YY_STATE_EOF(IN_STRING):
1708                         case YY_STATE_EOF(BEFORE_QUAL_QUOTE):
1709                                 yyterminate();
1710
1711         case YY_END_OF_BUFFER:
1712                 {
1713                 /* Amount of text matched not including the EOB char. */
1714                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1715
1716                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1717                 *yy_cp = yy_hold_char;
1718                 YY_RESTORE_YY_MORE_OFFSET
1719
1720                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1721                         {
1722                         /* We're scanning a new file or input source.  It's
1723                          * possible that this happened because the user
1724                          * just pointed yyin at a new source and called
1725                          * yylex().  If so, then we have to assure
1726                          * consistency between yy_current_buffer and our
1727                          * globals.  Here is the right place to do so, because
1728                          * this is the first action (other than possibly a
1729                          * back-up) that will match for the new input source.
1730                          */
1731                         yy_n_chars = yy_current_buffer->yy_n_chars;
1732                         yy_current_buffer->yy_input_file = yyin;
1733                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1734                         }
1735
1736                 /* Note that here we test for yy_c_buf_p "<=" to the position
1737                  * of the first EOB in the buffer, since yy_c_buf_p will
1738                  * already have been incremented past the NUL character
1739                  * (since all states make transitions on EOB to the
1740                  * end-of-buffer state).  Contrast this with the test
1741                  * in input().
1742                  */
1743                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1744                         { /* This was really a NUL. */
1745                         yy_state_type yy_next_state;
1746
1747                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1748
1749                         yy_current_state = yy_get_previous_state();
1750
1751                         /* Okay, we're now positioned to make the NUL
1752                          * transition.  We couldn't have
1753                          * yy_get_previous_state() go ahead and do it
1754                          * for us because it doesn't know how to deal
1755                          * with the possibility of jamming (and we don't
1756                          * want to build jamming into it because then it
1757                          * will run more slowly).
1758                          */
1759
1760                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1761
1762                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1763
1764                         if ( yy_next_state )
1765                                 {
1766                                 /* Consume the NUL. */
1767                                 yy_cp = ++yy_c_buf_p;
1768                                 yy_current_state = yy_next_state;
1769                                 goto yy_match;
1770                                 }
1771
1772                         else
1773                                 {
1774                                 yy_cp = yy_c_buf_p;
1775                                 goto yy_find_action;
1776                                 }
1777                         }
1778
1779                 else switch ( yy_get_next_buffer() )
1780                         {
1781                         case EOB_ACT_END_OF_FILE:
1782                                 {
1783                                 yy_did_buffer_switch_on_eof = 0;
1784
1785                                 if ( yywrap() )
1786                                         {
1787                                         /* Note: because we've taken care in
1788                                          * yy_get_next_buffer() to have set up
1789                                          * yytext, we can now set up
1790                                          * yy_c_buf_p so that if some total
1791                                          * hoser (like flex itself) wants to
1792                                          * call the scanner after we return the
1793                                          * YY_NULL, it'll still work - another
1794                                          * YY_NULL will get returned.
1795                                          */
1796                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1797
1798                                         yy_act = YY_STATE_EOF(YY_START);
1799                                         goto do_action;
1800                                         }
1801
1802                                 else
1803                                         {
1804                                         if ( ! yy_did_buffer_switch_on_eof )
1805                                                 YY_NEW_FILE;
1806                                         }
1807                                 break;
1808                                 }
1809
1810                         case EOB_ACT_CONTINUE_SCAN:
1811                                 yy_c_buf_p =
1812                                         yytext_ptr + yy_amount_of_matched_text;
1813
1814                                 yy_current_state = yy_get_previous_state();
1815
1816                                 yy_cp = yy_c_buf_p;
1817                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1818                                 goto yy_match;
1819
1820                         case EOB_ACT_LAST_MATCH:
1821                                 yy_c_buf_p =
1822                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1823
1824                                 yy_current_state = yy_get_previous_state();
1825
1826                                 yy_cp = yy_c_buf_p;
1827                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1828                                 goto yy_find_action;
1829                         }
1830                 break;
1831                 }
1832
1833         default:
1834                 YY_FATAL_ERROR(
1835                         "fatal flex scanner internal error--no action found" );
1836         } /* end of action switch */
1837                 } /* end of scanning one token */
1838         } /* end of yylex */
1839
1840
1841 /* yy_get_next_buffer - try to read in a new buffer
1842  *
1843  * Returns a code representing an action:
1844  *      EOB_ACT_LAST_MATCH -
1845  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1846  *      EOB_ACT_END_OF_FILE - end of file
1847  */
1848
1849 static int yy_get_next_buffer()
1850         {
1851         register char *dest = yy_current_buffer->yy_ch_buf;
1852         register char *source = yytext_ptr;
1853         register int number_to_move, i;
1854         int ret_val;
1855
1856         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1857                 YY_FATAL_ERROR(
1858                 "fatal flex scanner internal error--end of buffer missed" );
1859
1860         if ( yy_current_buffer->yy_fill_buffer == 0 )
1861                 { /* Don't try to fill the buffer, so this is an EOF. */
1862                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1863                         {
1864                         /* We matched a single character, the EOB, so
1865                          * treat this as a final EOF.
1866                          */
1867                         return EOB_ACT_END_OF_FILE;
1868                         }
1869
1870                 else
1871                         {
1872                         /* We matched some text prior to the EOB, first
1873                          * process it.
1874                          */
1875                         return EOB_ACT_LAST_MATCH;
1876                         }
1877                 }
1878
1879         /* Try to read more data. */
1880
1881         /* First move last chars to start of buffer. */
1882         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1883
1884         for ( i = 0; i < number_to_move; ++i )
1885                 *(dest++) = *(source++);
1886
1887         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1888                 /* don't do the read, it's not guaranteed to return an EOF,
1889                  * just force an EOF
1890                  */
1891                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1892
1893         else
1894                 {
1895                 int num_to_read =
1896                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1897
1898                 while ( num_to_read <= 0 )
1899                         { /* Not enough room in the buffer - grow it. */
1900 #ifdef YY_USES_REJECT
1901                         YY_FATAL_ERROR(
1902 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1903 #else
1904
1905                         /* just a shorter name for the current buffer */
1906                         YY_BUFFER_STATE b = yy_current_buffer;
1907
1908                         int yy_c_buf_p_offset =
1909                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1910
1911                         if ( b->yy_is_our_buffer )
1912                                 {
1913                                 int new_size = b->yy_buf_size * 2;
1914
1915                                 if ( new_size <= 0 )
1916                                         b->yy_buf_size += b->yy_buf_size / 8;
1917                                 else
1918                                         b->yy_buf_size *= 2;
1919
1920                                 b->yy_ch_buf = (char *)
1921                                         /* Include room in for 2 EOB chars. */
1922                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1923                                                          b->yy_buf_size + 2 );
1924                                 }
1925                         else
1926                                 /* Can't grow it, we don't own it. */
1927                                 b->yy_ch_buf = 0;
1928
1929                         if ( ! b->yy_ch_buf )
1930                                 YY_FATAL_ERROR(
1931                                 "fatal error - scanner input buffer overflow" );
1932
1933                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1934
1935                         num_to_read = yy_current_buffer->yy_buf_size -
1936                                                 number_to_move - 1;
1937 #endif
1938                         }
1939
1940                 if ( num_to_read > YY_READ_BUF_SIZE )
1941                         num_to_read = YY_READ_BUF_SIZE;
1942
1943                 /* Read in more data. */
1944                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1945                         yy_n_chars, num_to_read );
1946
1947                 yy_current_buffer->yy_n_chars = yy_n_chars;
1948                 }
1949
1950         if ( yy_n_chars == 0 )
1951                 {
1952                 if ( number_to_move == YY_MORE_ADJ )
1953                         {
1954                         ret_val = EOB_ACT_END_OF_FILE;
1955                         yyrestart( yyin );
1956                         }
1957
1958                 else
1959                         {
1960                         ret_val = EOB_ACT_LAST_MATCH;
1961                         yy_current_buffer->yy_buffer_status =
1962                                 YY_BUFFER_EOF_PENDING;
1963                         }
1964                 }
1965
1966         else
1967                 ret_val = EOB_ACT_CONTINUE_SCAN;
1968
1969         yy_n_chars += number_to_move;
1970         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1971         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1972
1973         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1974
1975         return ret_val;
1976         }
1977
1978
1979 /* yy_get_previous_state - get the state just before the EOB char was reached */
1980
1981 static yy_state_type yy_get_previous_state()
1982         {
1983         register yy_state_type yy_current_state;
1984         register char *yy_cp;
1985
1986         yy_current_state = yy_start;
1987         yy_state_ptr = yy_state_buf;
1988         *yy_state_ptr++ = yy_current_state;
1989
1990         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1991                 {
1992                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1993                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1994                         {
1995                         yy_current_state = (int) yy_def[yy_current_state];
1996                         if ( yy_current_state >= 363 )
1997                                 yy_c = yy_meta[(unsigned int) yy_c];
1998                         }
1999                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2000                 *yy_state_ptr++ = yy_current_state;
2001                 }
2002
2003         return yy_current_state;
2004         }
2005
2006
2007 /* yy_try_NUL_trans - try to make a transition on the NUL character
2008  *
2009  * synopsis
2010  *      next_state = yy_try_NUL_trans( current_state );
2011  */
2012
2013 #ifdef YY_USE_PROTOS
2014 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2015 #else
2016 static yy_state_type yy_try_NUL_trans( yy_current_state )
2017 yy_state_type yy_current_state;
2018 #endif
2019         {
2020         register int yy_is_jam;
2021
2022         register YY_CHAR yy_c = 1;
2023         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2024                 {
2025                 yy_current_state = (int) yy_def[yy_current_state];
2026                 if ( yy_current_state >= 363 )
2027                         yy_c = yy_meta[(unsigned int) yy_c];
2028                 }
2029         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2030         yy_is_jam = (yy_current_state == 362);
2031         if ( ! yy_is_jam )
2032                 *yy_state_ptr++ = yy_current_state;
2033
2034         return yy_is_jam ? 0 : yy_current_state;
2035         }
2036
2037
2038 #ifndef YY_NO_UNPUT
2039 #ifdef YY_USE_PROTOS
2040 static void yyunput( int c, register char *yy_bp )
2041 #else
2042 static void yyunput( c, yy_bp )
2043 int c;
2044 register char *yy_bp;
2045 #endif
2046         {
2047         register char *yy_cp = yy_c_buf_p;
2048
2049         /* undo effects of setting up yytext */
2050         *yy_cp = yy_hold_char;
2051
2052         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2053                 { /* need to shift things up to make room */
2054                 /* +2 for EOB chars. */
2055                 register int number_to_move = yy_n_chars + 2;
2056                 register char *dest = &yy_current_buffer->yy_ch_buf[
2057                                         yy_current_buffer->yy_buf_size + 2];
2058                 register char *source =
2059                                 &yy_current_buffer->yy_ch_buf[number_to_move];
2060
2061                 while ( source > yy_current_buffer->yy_ch_buf )
2062                         *--dest = *--source;
2063
2064                 yy_cp += (int) (dest - source);
2065                 yy_bp += (int) (dest - source);
2066                 yy_current_buffer->yy_n_chars =
2067                         yy_n_chars = yy_current_buffer->yy_buf_size;
2068
2069                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2070                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2071                 }
2072
2073         *--yy_cp = (char) c;
2074
2075
2076         yytext_ptr = yy_bp;
2077         yy_hold_char = *yy_cp;
2078         yy_c_buf_p = yy_cp;
2079         }
2080 #endif  /* ifndef YY_NO_UNPUT */
2081
2082
2083 #ifdef __cplusplus
2084 static int yyinput()
2085 #else
2086 static int input()
2087 #endif
2088         {
2089         int c;
2090
2091         *yy_c_buf_p = yy_hold_char;
2092
2093         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2094                 {
2095                 /* yy_c_buf_p now points to the character we want to return.
2096                  * If this occurs *before* the EOB characters, then it's a
2097                  * valid NUL; if not, then we've hit the end of the buffer.
2098                  */
2099                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2100                         /* This was really a NUL. */
2101                         *yy_c_buf_p = '\0';
2102
2103                 else
2104                         { /* need more input */
2105                         int offset = yy_c_buf_p - yytext_ptr;
2106                         ++yy_c_buf_p;
2107
2108                         switch ( yy_get_next_buffer() )
2109                                 {
2110                                 case EOB_ACT_LAST_MATCH:
2111                                         /* This happens because yy_g_n_b()
2112                                          * sees that we've accumulated a
2113                                          * token and flags that we need to
2114                                          * try matching the token before
2115                                          * proceeding.  But for input(),
2116                                          * there's no matching to consider.
2117                                          * So convert the EOB_ACT_LAST_MATCH
2118                                          * to EOB_ACT_END_OF_FILE.
2119                                          */
2120
2121                                         /* Reset buffer status. */
2122                                         yyrestart( yyin );
2123
2124                                         /* fall through */
2125
2126                                 case EOB_ACT_END_OF_FILE:
2127                                         {
2128                                         if ( yywrap() )
2129                                                 return EOF;
2130
2131                                         if ( ! yy_did_buffer_switch_on_eof )
2132                                                 YY_NEW_FILE;
2133 #ifdef __cplusplus
2134                                         return yyinput();
2135 #else
2136                                         return input();
2137 #endif
2138                                         }
2139
2140                                 case EOB_ACT_CONTINUE_SCAN:
2141                                         yy_c_buf_p = yytext_ptr + offset;
2142                                         break;
2143                                 }
2144                         }
2145                 }
2146
2147         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
2148         *yy_c_buf_p = '\0';     /* preserve yytext */
2149         yy_hold_char = *++yy_c_buf_p;
2150
2151
2152         return c;
2153         }
2154
2155
2156 #ifdef YY_USE_PROTOS
2157 void yyrestart( FILE *input_file )
2158 #else
2159 void yyrestart( input_file )
2160 FILE *input_file;
2161 #endif
2162         {
2163         if ( ! yy_current_buffer )
2164                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2165
2166         yy_init_buffer( yy_current_buffer, input_file );
2167         yy_load_buffer_state();
2168         }
2169
2170
2171 #ifdef YY_USE_PROTOS
2172 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2173 #else
2174 void yy_switch_to_buffer( new_buffer )
2175 YY_BUFFER_STATE new_buffer;
2176 #endif
2177         {
2178         if ( yy_current_buffer == new_buffer )
2179                 return;
2180
2181         if ( yy_current_buffer )
2182                 {
2183                 /* Flush out information for old buffer. */
2184                 *yy_c_buf_p = yy_hold_char;
2185                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2186                 yy_current_buffer->yy_n_chars = yy_n_chars;
2187                 }
2188
2189         yy_current_buffer = new_buffer;
2190         yy_load_buffer_state();
2191
2192         /* We don't actually know whether we did this switch during
2193          * EOF (yywrap()) processing, but the only time this flag
2194          * is looked at is after yywrap() is called, so it's safe
2195          * to go ahead and always set it.
2196          */
2197         yy_did_buffer_switch_on_eof = 1;
2198         }
2199
2200
2201 #ifdef YY_USE_PROTOS
2202 void yy_load_buffer_state( void )
2203 #else
2204 void yy_load_buffer_state()
2205 #endif
2206         {
2207         yy_n_chars = yy_current_buffer->yy_n_chars;
2208         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2209         yyin = yy_current_buffer->yy_input_file;
2210         yy_hold_char = *yy_c_buf_p;
2211         }
2212
2213
2214 #ifdef YY_USE_PROTOS
2215 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2216 #else
2217 YY_BUFFER_STATE yy_create_buffer( file, size )
2218 FILE *file;
2219 int size;
2220 #endif
2221         {
2222         YY_BUFFER_STATE b;
2223
2224         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2225         if ( ! b )
2226                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2227
2228         b->yy_buf_size = size;
2229
2230         /* yy_ch_buf has to be 2 characters longer than the size given because
2231          * we need to put in 2 end-of-buffer characters.
2232          */
2233         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2234         if ( ! b->yy_ch_buf )
2235                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2236
2237         b->yy_is_our_buffer = 1;
2238
2239         yy_init_buffer( b, file );
2240
2241         return b;
2242         }
2243
2244
2245 #ifdef YY_USE_PROTOS
2246 void yy_delete_buffer( YY_BUFFER_STATE b )
2247 #else
2248 void yy_delete_buffer( b )
2249 YY_BUFFER_STATE b;
2250 #endif
2251         {
2252         if ( ! b )
2253                 return;
2254
2255         if ( b == yy_current_buffer )
2256                 yy_current_buffer = (YY_BUFFER_STATE) 0;
2257
2258         if ( b->yy_is_our_buffer )
2259                 yy_flex_free( (void *) b->yy_ch_buf );
2260
2261         yy_flex_free( (void *) b );
2262         }
2263
2264
2265 #ifndef YY_ALWAYS_INTERACTIVE
2266 #ifndef YY_NEVER_INTERACTIVE
2267 extern int isatty YY_PROTO(( int ));
2268 #endif
2269 #endif
2270
2271 #ifdef YY_USE_PROTOS
2272 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2273 #else
2274 void yy_init_buffer( b, file )
2275 YY_BUFFER_STATE b;
2276 FILE *file;
2277 #endif
2278
2279
2280         {
2281         yy_flush_buffer( b );
2282
2283         b->yy_input_file = file;
2284         b->yy_fill_buffer = 1;
2285
2286 #if YY_ALWAYS_INTERACTIVE
2287         b->yy_is_interactive = 1;
2288 #else
2289 #if YY_NEVER_INTERACTIVE
2290         b->yy_is_interactive = 0;
2291 #else
2292         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2293 #endif
2294 #endif
2295         }
2296
2297
2298 #ifdef YY_USE_PROTOS
2299 void yy_flush_buffer( YY_BUFFER_STATE b )
2300 #else
2301 void yy_flush_buffer( b )
2302 YY_BUFFER_STATE b;
2303 #endif
2304
2305         {
2306         if ( ! b )
2307                 return;
2308
2309         b->yy_n_chars = 0;
2310
2311         /* We always need two end-of-buffer characters.  The first causes
2312          * a transition to the end-of-buffer state.  The second causes
2313          * a jam in that state.
2314          */
2315         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2316         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2317
2318         b->yy_buf_pos = &b->yy_ch_buf[0];
2319
2320         b->yy_at_bol = 1;
2321         b->yy_buffer_status = YY_BUFFER_NEW;
2322
2323         if ( b == yy_current_buffer )
2324                 yy_load_buffer_state();
2325         }
2326
2327
2328 #ifndef YY_NO_SCAN_BUFFER
2329 #ifdef YY_USE_PROTOS
2330 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2331 #else
2332 YY_BUFFER_STATE yy_scan_buffer( base, size )
2333 char *base;
2334 yy_size_t size;
2335 #endif
2336         {
2337         YY_BUFFER_STATE b;
2338
2339         if ( size < 2 ||
2340              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2341              base[size-1] != YY_END_OF_BUFFER_CHAR )
2342                 /* They forgot to leave room for the EOB's. */
2343                 return 0;
2344
2345         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2346         if ( ! b )
2347                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2348
2349         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2350         b->yy_buf_pos = b->yy_ch_buf = base;
2351         b->yy_is_our_buffer = 0;
2352         b->yy_input_file = 0;
2353         b->yy_n_chars = b->yy_buf_size;
2354         b->yy_is_interactive = 0;
2355         b->yy_at_bol = 1;
2356         b->yy_fill_buffer = 0;
2357         b->yy_buffer_status = YY_BUFFER_NEW;
2358
2359         yy_switch_to_buffer( b );
2360
2361         return b;
2362         }
2363 #endif
2364
2365
2366 #ifndef YY_NO_SCAN_STRING
2367 #ifdef YY_USE_PROTOS
2368 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2369 #else
2370 YY_BUFFER_STATE yy_scan_string( yy_str )
2371 yyconst char *yy_str;
2372 #endif
2373         {
2374         int len;
2375         for ( len = 0; yy_str[len]; ++len )
2376                 ;
2377
2378         return yy_scan_bytes( yy_str, len );
2379         }
2380 #endif
2381
2382
2383 #ifndef YY_NO_SCAN_BYTES
2384 #ifdef YY_USE_PROTOS
2385 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2386 #else
2387 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2388 yyconst char *bytes;
2389 int len;
2390 #endif
2391         {
2392         YY_BUFFER_STATE b;
2393         char *buf;
2394         yy_size_t n;
2395         int i;
2396
2397         /* Get memory for full buffer, including space for trailing EOB's. */
2398         n = len + 2;
2399         buf = (char *) yy_flex_alloc( n );
2400         if ( ! buf )
2401                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2402
2403         for ( i = 0; i < len; ++i )
2404                 buf[i] = bytes[i];
2405
2406         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2407
2408         b = yy_scan_buffer( buf, n );
2409         if ( ! b )
2410                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2411
2412         /* It's okay to grow etc. this buffer, and we should throw it
2413          * away when we're done.
2414          */
2415         b->yy_is_our_buffer = 1;
2416
2417         return b;
2418         }
2419 #endif
2420
2421
2422 #ifndef YY_NO_PUSH_STATE
2423 #ifdef YY_USE_PROTOS
2424 static void yy_push_state( int new_state )
2425 #else
2426 static void yy_push_state( new_state )
2427 int new_state;
2428 #endif
2429         {
2430         if ( yy_start_stack_ptr >= yy_start_stack_depth )
2431                 {
2432                 yy_size_t new_size;
2433
2434                 yy_start_stack_depth += YY_START_STACK_INCR;
2435                 new_size = yy_start_stack_depth * sizeof( int );
2436
2437                 if ( ! yy_start_stack )
2438                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2439
2440                 else
2441                         yy_start_stack = (int *) yy_flex_realloc(
2442                                         (void *) yy_start_stack, new_size );
2443
2444                 if ( ! yy_start_stack )
2445                         YY_FATAL_ERROR(
2446                         "out of memory expanding start-condition stack" );
2447                 }
2448
2449         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2450
2451         BEGIN(new_state);
2452         }
2453 #endif
2454
2455
2456 #ifndef YY_NO_POP_STATE
2457 static void yy_pop_state()
2458         {
2459         if ( --yy_start_stack_ptr < 0 )
2460                 YY_FATAL_ERROR( "start-condition stack underflow" );
2461
2462         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2463         }
2464 #endif
2465
2466
2467 #ifndef YY_NO_TOP_STATE
2468 static int yy_top_state()
2469         {
2470         return yy_start_stack[yy_start_stack_ptr - 1];
2471         }
2472 #endif
2473
2474 #ifndef YY_EXIT_FAILURE
2475 #define YY_EXIT_FAILURE 2
2476 #endif
2477
2478 #ifdef YY_USE_PROTOS
2479 static void yy_fatal_error( yyconst char msg[] )
2480 #else
2481 static void yy_fatal_error( msg )
2482 char msg[];
2483 #endif
2484         {
2485         (void) fprintf( stderr, "%s\n", msg );
2486         exit( YY_EXIT_FAILURE );
2487         }
2488
2489
2490
2491 /* Redefine yyless() so it works in section 3 code. */
2492
2493 #undef yyless
2494 #define yyless(n) \
2495         do \
2496                 { \
2497                 /* Undo effects of setting up yytext. */ \
2498                 yytext[yyleng] = yy_hold_char; \
2499                 yy_c_buf_p = yytext + n; \
2500                 yy_hold_char = *yy_c_buf_p; \
2501                 *yy_c_buf_p = '\0'; \
2502                 yyleng = n; \
2503                 } \
2504         while ( 0 )
2505
2506
2507 /* Internal utility routines. */
2508
2509 #ifndef yytext_ptr
2510 #ifdef YY_USE_PROTOS
2511 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2512 #else
2513 static void yy_flex_strncpy( s1, s2, n )
2514 char *s1;
2515 yyconst char *s2;
2516 int n;
2517 #endif
2518         {
2519         register int i;
2520         for ( i = 0; i < n; ++i )
2521                 s1[i] = s2[i];
2522         }
2523 #endif
2524
2525 #ifdef YY_NEED_STRLEN
2526 #ifdef YY_USE_PROTOS
2527 static int yy_flex_strlen( yyconst char *s )
2528 #else
2529 static int yy_flex_strlen( s )
2530 yyconst char *s;
2531 #endif
2532         {
2533         register int n;
2534         for ( n = 0; s[n]; ++n )
2535                 ;
2536
2537         return n;
2538         }
2539 #endif
2540
2541
2542 #ifdef YY_USE_PROTOS
2543 static void *yy_flex_alloc( yy_size_t size )
2544 #else
2545 static void *yy_flex_alloc( size )
2546 yy_size_t size;
2547 #endif
2548         {
2549         return (void *) malloc( size );
2550         }
2551
2552 #ifdef YY_USE_PROTOS
2553 static void *yy_flex_realloc( void *ptr, yy_size_t size )
2554 #else
2555 static void *yy_flex_realloc( ptr, size )
2556 void *ptr;
2557 yy_size_t size;
2558 #endif
2559         {
2560         /* The cast to (char *) in the following accommodates both
2561          * implementations that use char* generic pointers, and those
2562          * that use void* generic pointers.  It works with the latter
2563          * because both ANSI C and C++ allow castless assignment from
2564          * any pointer type to void*, and deal with argument conversions
2565          * as though doing an assignment.
2566          */
2567         return (void *) realloc( (char *) ptr, size );
2568         }
2569
2570 #ifdef YY_USE_PROTOS
2571 static void yy_flex_free( void *ptr )
2572 #else
2573 static void yy_flex_free( ptr )
2574 void *ptr;
2575 #endif
2576         {
2577         free( ptr );
2578         }
2579
2580 #if YY_MAIN
2581 int main()
2582         {
2583         yylex();
2584         return 0;
2585         }
2586 #endif
2587 #line 342 "./ada-lex.l"
2588
2589
2590 #include <ctype.h>
2591 #include <string.h>
2592
2593 /* Initialize the lexer for processing new expression */
2594 void
2595 lexer_init (FILE* inp)
2596 {
2597   BEGIN INITIAL;
2598   yyrestart (inp);
2599 }
2600
2601
2602 /* Make sure that tempbuf points at an array at least N characters long. */
2603
2604 static void
2605 resize_tempbuf (n)
2606      unsigned int n;
2607 {
2608   if (tempbufsize < n)
2609     {
2610       tempbufsize = (n+63) & ~63;
2611       tempbuf = (char*) xrealloc (tempbuf, tempbufsize);
2612     }
2613 }
2614
2615 /* Copy S2 to S1, removing all underscores, and downcasing all letters. */
2616
2617 static void
2618 canonicalizeNumeral (s1,s2)
2619      char* s1;
2620      const char* s2;
2621 {
2622   for (; *s2 != '\000'; s2 += 1)
2623     {
2624       if (*s2 != '_')
2625         {
2626           *s1 = tolower(*s2);
2627           s1 += 1;
2628         }
2629     }
2630   s1[0] = '\000';
2631 }
2632
2633 #define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
2634
2635 /* True (non-zero) iff DIGIT is a valid digit in radix BASE,
2636    where 2 <= BASE <= 16.  */
2637
2638 static int
2639 is_digit_in_base (digit, base)
2640      unsigned char digit;
2641      int base;
2642 {
2643   if (!isxdigit (digit))
2644     return 0;
2645   if (base <= 10)
2646     return (isdigit (digit) && digit < base + '0');
2647   else
2648     return (isdigit (digit) || tolower (digit) < base - 10 + 'a');
2649 }
2650
2651 static int
2652 digit_to_int (c)
2653      unsigned char c;
2654 {
2655   if (isdigit (c))
2656     return c - '0';
2657   else
2658     return tolower (c) - 'a' + 10;
2659 }
2660
2661 /* As for strtoul, but for ULONGEST results. */
2662 ULONGEST
2663 strtoulst (num, trailer, base)
2664      const char *num;
2665      const char **trailer;
2666      int base;
2667 {
2668   unsigned int high_part;
2669   ULONGEST result;
2670   int i;
2671   unsigned char lim;
2672
2673   if (base < 2 || base > 16)
2674     {
2675       errno = EINVAL;
2676       return 0;
2677     }
2678   lim = base - 1 + '0';
2679
2680   result = high_part = 0;
2681   for (i = 0; is_digit_in_base (num[i], base); i += 1)
2682     {
2683       result = result*base + digit_to_int (num[i]);
2684       high_part = high_part*base + (unsigned int) (result >> HIGH_BYTE_POSN);
2685       result &= ((ULONGEST) 1 << HIGH_BYTE_POSN) - 1;
2686       if (high_part > 0xff)
2687         {
2688           errno = ERANGE;
2689           result = high_part = 0;
2690           break;
2691         }
2692     }
2693
2694   if (trailer != NULL)
2695     *trailer = &num[i];
2696
2697   return result + ((ULONGEST) high_part << HIGH_BYTE_POSN);
2698 }
2699
2700
2701
2702 /* Interprets the prefix of NUM that consists of digits of the given BASE
2703    as an integer of that BASE, with the string EXP as an exponent.
2704    Puts value in yylval, and returns INT, if the string is valid.  Causes
2705    an error if the number is improperly formated.   BASE, if NULL, defaults
2706    to "10", and EXP to "1". The EXP does not contain a leading 'e' or 'E'. */
2707
2708 static int
2709 processInt (base0, num0, exp0)
2710      const char* num0;
2711      const char* base0;
2712      const char* exp0;
2713 {
2714   ULONGEST result;
2715   long exp;
2716   int base;
2717
2718   char* trailer;
2719
2720   if (base0 == NULL)
2721     base = 10;
2722   else
2723     {
2724       base = strtol (base0, (char**) NULL, 10);
2725       if (base < 2 || base > 16)
2726         error ("Invalid base: %d.", base);
2727     }
2728
2729   if (exp0 == NULL)
2730     exp = 0;
2731   else
2732     exp = strtol(exp0, (char**) NULL, 10);
2733
2734   errno = 0;
2735   result = strtoulst (num0, &trailer, base);
2736   if (errno == ERANGE)
2737     error ("Integer literal out of range");
2738   if (isxdigit(*trailer))
2739     error ("Invalid digit `%c' in based literal", *trailer);
2740
2741   while (exp > 0)
2742     {
2743       if (result > (ULONG_MAX / base))
2744         error ("Integer literal out of range");
2745       result *= base;
2746       exp -= 1;
2747     }
2748
2749   if ((result >> (TARGET_INT_BIT-1)) == 0)
2750     yylval.typed_val.type = builtin_type_ada_int;
2751   else if ((result >> (TARGET_LONG_BIT-1)) == 0)
2752     yylval.typed_val.type = builtin_type_ada_long;
2753   else if (((result >> (TARGET_LONG_BIT-1)) >> 1) == 0)
2754     {
2755       /* We have a number representable as an unsigned integer quantity.
2756          For consistency with the C treatment, we will treat it as an
2757          anonymous modular (unsigned) quantity.  Alas, the types are such
2758          that we need to store .val as a signed quantity.  Sorry
2759          for the mess, but C doesn't officially guarantee that a simple
2760          assignment does the trick (no, it doesn't; read the reference manual).
2761        */
2762       yylval.typed_val.type = builtin_type_unsigned_long;
2763       if (result & LONGEST_SIGN)
2764         yylval.typed_val.val =
2765           (LONGEST) (result & ~LONGEST_SIGN)
2766           - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
2767       else
2768         yylval.typed_val.val = (LONGEST) result;
2769       return INT;
2770     }
2771   else
2772     yylval.typed_val.type = builtin_type_ada_long_long;
2773
2774   yylval.typed_val.val = (LONGEST) result;
2775   return INT;
2776 }
2777
2778 static int
2779 processReal (num0)
2780      const char* num0;
2781 {
2782   if (sizeof (DOUBLEST) <= sizeof (float))
2783     sscanf (num0, "%g", &yylval.typed_val_float.dval);
2784   else if (sizeof (DOUBLEST) <= sizeof (double))
2785     sscanf (num0, "%lg", &yylval.typed_val_float.dval);
2786   else
2787     {
2788 #ifdef PRINTF_HAS_LONG_DOUBLE
2789       sscanf (num0, "%Lg", &yylval.typed_val_float.dval);
2790 #else
2791       /* Scan it into a double, then convert and assign it to the
2792          long double.  This at least wins with values representable
2793          in the range of doubles. */
2794       double temp;
2795       sscanf (num0, "%lg", &temp);
2796       yylval.typed_val_float.dval = temp;
2797 #endif
2798     }
2799
2800   yylval.typed_val_float.type = builtin_type_ada_float;
2801   if (sizeof(DOUBLEST) >= TARGET_DOUBLE_BIT / TARGET_CHAR_BIT)
2802     yylval.typed_val_float.type = builtin_type_ada_double;
2803   if (sizeof(DOUBLEST) >= TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT)
2804     yylval.typed_val_float.type = builtin_type_ada_long_double;
2805
2806   return FLOAT;
2807 }
2808
2809 static int
2810 processId (name0, len)
2811      const char *name0;
2812      int len;
2813 {
2814   char* name = xmalloc (len + 11);
2815   int i0, i;
2816
2817 /*  add_name_string_cleanup (name); */
2818 /* FIXME: add_name_string_cleanup should be defined in parse.c */
2819   while (len > 0 && isspace (name0[len-1]))
2820     len -= 1;
2821   i = i0 = 0;
2822   while (i0 < len)
2823     {
2824       if (isalnum (name0[i0]))
2825         {
2826           name[i] = tolower (name0[i0]);
2827           i += 1; i0 += 1;
2828         }
2829       else switch (name0[i0])
2830         {
2831         default:
2832           name[i] = name0[i0];
2833           i += 1; i0 += 1;
2834           break;
2835         case ' ': case '\t':
2836           i0 += 1;
2837           break;
2838         case '\'':
2839           i0 += 1;
2840           while (i0 < len && name0[i0] != '\'')
2841             {
2842               name[i] = name0[i0];
2843               i += 1; i0 += 1;
2844             }
2845           i0 += 1;
2846           break;
2847         case '<':
2848           i0 += 1;
2849           while (i0 < len && name0[i0] != '>')
2850             {
2851               name[i] = name0[i0];
2852               i += 1; i0 += 1;
2853             }
2854           i0 += 1;
2855           break;
2856         }
2857     }
2858   name[i] = '\000';
2859
2860   yylval.ssym.sym = NULL;
2861   yylval.ssym.stoken.ptr = name;
2862   yylval.ssym.stoken.length = i;
2863   return NAME;
2864 }
2865
2866 static void
2867 block_lookup (name, err_name)
2868      char* name;
2869      char* err_name;
2870 {
2871   struct symbol** syms;
2872   struct block** blocks;
2873   int nsyms;
2874   struct symtab *symtab;
2875   nsyms = ada_lookup_symbol_list (name, left_block_context,
2876                                   VAR_NAMESPACE, &syms, &blocks);
2877   if (left_block_context == NULL &&
2878       (nsyms == 0 || SYMBOL_CLASS (syms[0]) != LOC_BLOCK))
2879     symtab = lookup_symtab (name);
2880   else
2881     symtab = NULL;
2882
2883   if (symtab != NULL)
2884     left_block_context = yylval.bval =
2885       BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
2886   else if (nsyms == 0 || SYMBOL_CLASS (syms[0]) != LOC_BLOCK)
2887     {
2888       if (left_block_context == NULL)
2889         error ("No file or function \"%s\".", err_name);
2890       else
2891         error ("No function \"%s\" in specified context.", err_name);
2892     }
2893   else
2894     {
2895       left_block_context = yylval.bval = SYMBOL_BLOCK_VALUE (syms[0]);
2896       if (nsyms > 1)
2897         warning ("Function name \"%s\" ambiguous here", err_name);
2898     }
2899 }
2900
2901 /* Look up NAME0 (assumed to be mangled) as a name in VAR_NAMESPACE,
2902    setting *TOKEN_TYPE to NAME or TYPENAME, depending on what is
2903    found.  Try first the entire name, then the name without the last
2904    segment (i.e., after the last .id), etc., and return the number of
2905    segments that had to be removed to get a match.  Calls error if no
2906    matches are found, using ERR_NAME in any error message.  When
2907    exactly one symbol match is found, it is placed in yylval. */
2908
2909 static int
2910 name_lookup (name0, err_name, token_type)
2911      char* name0;
2912      char* err_name;
2913      int* token_type;
2914 {
2915   struct symbol** syms;
2916   struct block** blocks;
2917   struct type* type;
2918   int len0 = strlen (name0);
2919   char* name = savestring (name0, len0);
2920   int nsyms;
2921   int segments;
2922
2923 /*  add_name_string_cleanup (name);*/
2924 /* FIXME: add_name_string_cleanup should be defined in parse.c */
2925   yylval.ssym.stoken.ptr = name;
2926   yylval.ssym.stoken.length = strlen (name);
2927   for (segments = 0; ; segments += 1)
2928     {
2929       struct type* preferred_type;
2930       int i, preferred_index;
2931
2932       if (left_block_context == NULL)
2933         nsyms = ada_lookup_symbol_list (name, expression_context_block,
2934                                         VAR_NAMESPACE, &syms, &blocks);
2935       else
2936         nsyms = ada_lookup_symbol_list (name, left_block_context,
2937                                         VAR_NAMESPACE, &syms, &blocks);
2938
2939       /* Check for a type definition. */
2940
2941       /* Look for a symbol that doesn't denote void.  This is (I think) a */
2942       /* temporary kludge to get around problems in GNAT output. */
2943       preferred_index = -1; preferred_type = NULL;
2944       for (i = 0; i < nsyms; i += 1)
2945         switch (SYMBOL_CLASS (syms[i]))
2946           {
2947           case LOC_TYPEDEF:
2948             if (ada_prefer_type (SYMBOL_TYPE (syms[i]), preferred_type))
2949               {
2950                 preferred_index = i;
2951                 preferred_type = SYMBOL_TYPE (syms[i]);
2952               }
2953             break;
2954           case LOC_REGISTER:
2955           case LOC_ARG:
2956           case LOC_REF_ARG:
2957           case LOC_REGPARM:
2958           case LOC_REGPARM_ADDR:
2959           case LOC_LOCAL:
2960           case LOC_LOCAL_ARG:
2961           case LOC_BASEREG:
2962           case LOC_BASEREG_ARG:
2963             goto NotType;
2964           default:
2965             break;
2966           }
2967       if (preferred_type != NULL)
2968         {
2969 /*        if (TYPE_CODE (preferred_type) == TYPE_CODE_VOID)
2970             error ("`%s' matches only void type name(s)",
2971                    ada_demangle (name));
2972 */
2973 /* FIXME: ada_demangle should be defined in defs.h, and is located in ada-lang.c */
2974 /*        else*/ if (ada_is_object_renaming (syms[preferred_index]))
2975             {
2976               yylval.ssym.sym = syms[preferred_index];
2977               *token_type = OBJECT_RENAMING;
2978               return segments;
2979             }
2980           else if (ada_renaming_type (SYMBOL_TYPE (syms[preferred_index]))
2981                    != NULL)
2982             {
2983               int result;
2984               const char* renaming =
2985                 ada_simple_renamed_entity (syms[preferred_index]);
2986               char* new_name = xmalloc (strlen (renaming) + len0
2987                                         - yylval.ssym.stoken.length + 1);
2988 /*            add_name_string_cleanup (new_name);*/
2989 /* FIXME: add_name_string_cleanup should be defined in parse.c */
2990               strcpy (new_name, renaming);
2991               strcat (new_name, name0 + yylval.ssym.stoken.length);
2992               result = name_lookup (new_name, err_name, token_type);
2993               if (result > segments)
2994                 error ("Confused by renamed symbol.");
2995               return result;
2996             }
2997           else if (segments == 0)
2998             {
2999               yylval.tval = preferred_type;
3000               *token_type = TYPENAME;
3001               return 0;
3002             }
3003         }
3004
3005       if (segments == 0)
3006         {
3007           type = lookup_primitive_typename (name);
3008           if (type == NULL && STREQ ("system__address", name))
3009             type = builtin_type_ada_system_address;
3010           if (type != NULL)
3011             {
3012               yylval.tval = type;
3013               *token_type = TYPENAME;
3014               return 0;
3015             }
3016         }
3017
3018     NotType:
3019       if (nsyms == 1)
3020         {
3021           *token_type = NAME;
3022           yylval.ssym.sym = syms[0];
3023           yylval.ssym.msym = NULL;
3024           yylval.ssym.block = blocks[0];
3025           return segments;
3026         }
3027       else if (nsyms == 0) {
3028         int i;
3029         yylval.ssym.msym = ada_lookup_minimal_symbol (name);
3030         if (yylval.ssym.msym != NULL)
3031           {
3032             yylval.ssym.sym = NULL;
3033             yylval.ssym.block = NULL;
3034             *token_type = NAME;
3035             return segments;
3036           }
3037
3038         for (i = yylval.ssym.stoken.length - 1; i > 0; i -= 1)
3039           {
3040             if (name[i] == '.')
3041               {
3042                 name[i] = '\0';
3043                 yylval.ssym.stoken.length = i;
3044                 break;
3045               }
3046             else if (name[i] == '_' && name[i-1] == '_')
3047               {
3048                 i -= 1;
3049                 name[i] = '\0';
3050                 yylval.ssym.stoken.length = i;
3051                 break;
3052               }
3053           }
3054         if (i <= 0)
3055           {
3056             if (!have_full_symbols () && !have_partial_symbols ()
3057                 && left_block_context == NULL)
3058               error ("No symbol table is loaded.  Use the \"file\" command.");
3059             if (left_block_context == NULL)
3060               error ("No definition of \"%s\" in current context.",
3061                      err_name);
3062             else
3063               error ("No definition of \"%s\" in specified context.",
3064                      err_name);
3065           }
3066       }
3067       else
3068         {
3069           *token_type = NAME;
3070           yylval.ssym.sym = NULL;
3071           yylval.ssym.msym = NULL;
3072           if (left_block_context == NULL)
3073             yylval.ssym.block = expression_context_block;
3074           else
3075             yylval.ssym.block = left_block_context;
3076           return segments;
3077         }
3078     }
3079 }
3080
3081 /* Returns the position within STR of the '.' in a
3082    '.{WHITE}*all' component of a dotted name, or -1 if there is none. */
3083 static int
3084 find_dot_all (str)
3085      const char* str;
3086 {
3087   int i;
3088   for (i = 0; str[i] != '\000'; i += 1)
3089     {
3090       if (str[i] == '.')
3091         {
3092           int i0 = i;
3093           do
3094             i += 1;
3095           while (isspace (str[i]));
3096           if (strcmp (str+i, "all") == 0
3097               && ! isalnum (str[i+3]) && str[i+3] != '_')
3098             return i0;
3099         }
3100     }
3101   return -1;
3102 }
3103
3104 /* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
3105    case. */
3106
3107 static int
3108 subseqMatch (subseq, str)
3109      const char* subseq;
3110      const char* str;
3111 {
3112   if (subseq[0] == '\0')
3113     return 1;
3114   else if (str[0] == '\0')
3115     return 0;
3116   else if (tolower (subseq[0]) == tolower (str[0]))
3117     return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
3118   else
3119     return subseqMatch (subseq, str+1);
3120 }
3121
3122
3123 static struct { const char* name; int code; }
3124 attributes[] = {
3125   { "address", TICK_ADDRESS },
3126   { "unchecked_access", TICK_ACCESS },
3127   { "unrestricted_access", TICK_ACCESS },
3128   { "access", TICK_ACCESS },
3129   { "first", TICK_FIRST },
3130   { "last", TICK_LAST },
3131   { "length", TICK_LENGTH },
3132   { "max", TICK_MAX },
3133   { "min", TICK_MIN },
3134   { "modulus", TICK_MODULUS },
3135   { "pos", TICK_POS },
3136   { "range", TICK_RANGE },
3137   { "size", TICK_SIZE },
3138   { "tag", TICK_TAG },
3139   { "val", TICK_VAL },
3140   { NULL, -1 }
3141 };
3142
3143 /* Return the syntactic code corresponding to the attribute name or
3144    abbreviation STR.  */
3145
3146 static int
3147 processAttribute (str)
3148      const char* str;
3149 {
3150   int i, k;
3151
3152   for (i = 0; attributes[i].code != -1; i += 1)
3153     if (strcasecmp (str, attributes[i].name) == 0)
3154       return attributes[i].code;
3155
3156   for (i = 0, k = -1; attributes[i].code != -1; i += 1)
3157     if (subseqMatch (str, attributes[i].name))
3158       {
3159         if (k == -1)
3160           k = i;
3161         else
3162           error ("ambiguous attribute name: `%s'", str);
3163       }
3164   if (k == -1)
3165     error ("unrecognized attribute: `%s'", str);
3166
3167   return attributes[k].code;
3168 }
3169
3170 int
3171 yywrap()
3172 {
3173   return 1;
3174 }