gnu/usr.bin/gdb/gdb/ada-lex.c

   1 #line 2 "ada-lex.c"
   2 /* A lexical scanner generated by flex */
   3
   4 /* Scanner skeleton version:
   5  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern 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 #include <unistd.h>
  14
  15
  16 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  17 #ifdef c_plusplus
  18 #ifndef __cplusplus
  19 #define __cplusplus
  20 #endif
  21 #endif
  22
  23
  24 #ifdef __cplusplus
  25
  26 #include <stdlib.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 xrealloc() it to grow it, and should xfree() 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 *yyxrealloc 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 typedef unsigned char YY_CHAR;
 266 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 267 typedef int yy_state_type;
 268 extern char *yytext;
 269 #define yytext_ptr yytext
 270
 271 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 272 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 273 static int yy_get_next_buffer YY_PROTO(( void ));
 274 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 275
 276 /* Done after the current pattern has been matched and before the
 277  * corresponding action - sets up yytext.
 278  */
 279 #define YY_DO_BEFORE_ACTION \
 280         yytext_ptr = yy_bp; \
 281         yyleng = (int) (yy_cp - yy_bp); \
 282         yy_hold_char = *yy_cp; \
 283         *yy_cp = '\0'; \
 284         yy_c_buf_p = yy_cp;
 285
 286 #define YY_NUM_RULES 54
 287 #define YY_END_OF_BUFFER 55
 288 static yyconst short int yy_accept[196] =
 289     {   0,
 290         0,    0,    0,    0,   55,   53,    1,    1,   15,   52,
 291        42,   53,   44,   45,   42,   43,   42,   42,   42,    4,
 292         4,   42,   42,   42,   42,   51,   48,   48,   48,   48,
 293        48,   48,   48,   48,   48,   48,   48,   41,    0,   14,
 294         0,   52,    0,    0,    0,    0,    0,    0,    0,   36,
 295         2,    0,   35,    0,   47,   47,   38,    0,    0,    4,
 296         0,    0,   50,   37,   39,    0,   34,   40,    0,    0,
 297        48,    0,   48,   48,   48,   48,   48,   16,   21,   48,
 298        48,   48,   48,   26,   48,   48,   48,   48,   48,   48,
 299         0,   14,    0,   12,   12,    0,   33,    2,    0,   47,
 300
 301        47,    0,    9,    0,    3,    7,    0,   48,    0,    0,
 302         0,   48,   18,   19,   48,   48,   22,   23,   24,   48,
 303        48,   28,   48,   48,   48,   48,   30,    0,    0,    0,
 304         0,    0,    0,   47,   46,    6,    0,    0,    9,    0,
 305         3,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 306         0,    0,    0,   48,   20,   48,   25,   48,   17,   29,
 307        48,   31,    0,   49,    0,    0,    0,    0,   48,    0,
 308         0,    0,    0,    0,    0,    0,   32,   48,   48,    0,
 309         0,    5,   11,    0,    8,   27,    0,    5,    0,    8,
 310        13,    0,   10,   10,    0
 311
 312     } ;
 313
 314 static yyconst int yy_ec[256] =
 315     {   0,
 316         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 317         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 318         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 319         1,    4,    5,    6,    7,    8,    5,    9,   10,   11,
 320        12,   13,   14,   15,   16,   17,   18,   19,   20,   20,
 321        20,   20,   20,   20,   20,   20,   20,   21,   22,   23,
 322        24,   25,    5,   26,   30,   31,   32,   33,   34,   35,
 323        36,   37,   38,   36,   39,   40,   41,   42,   43,   36,
 324        36,   44,   45,   46,   47,   36,   48,   49,   36,   36,
 325        27,    5,   28,    5,   29,    5,   30,   31,   32,   33,
 326
 327        34,   35,   36,   37,   38,   36,   39,   40,   41,   42,
 328        43,   36,   36,   44,   45,   46,   47,   36,   48,   49,
 329        36,   36,   26,   22,   26,    5,    1,    1,    1,    1,
 330         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 331         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 332         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 333         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 334         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 335         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 336         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 337
 338         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 339         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 340         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 341         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 342         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 343         1,    1,    1,    1,    1
 344     } ;
 345
 346 static yyconst int yy_meta[50] =
 347     {   0,
 348         1,    2,    3,    4,    5,    6,    7,    8,    5,    9,
 349         5,    5,    5,    5,    5,    5,   10,    5,   11,   11,
 350         5,    5,   12,   13,   14,    5,    5,    5,   15,   16,
 351        16,   16,   16,   16,   16,   17,   17,   17,   17,   17,
 352        17,   17,   17,   17,   17,   17,   17,   17,   17
 353     } ;
 354
 355 static yyconst short int yy_base[217] =
 356     {   0,
 357         0,    0,  622,  615,  620,  759,  759,  759,   44,    0,
 358       759,   71,  759,  759,  606,  759,  601,  119,  591,  118,
 359       124,   30,  590,  588,  588,  759,   53,  152,   22,   97,
 360        98,  103,  117,  119,   27,  140,  137,  194,  151,  759,
 361       160,    0,  242,  601,  594,  593,  592,  120,  282,  759,
 362         0,  330,  759,    0,    0,  560,  759,    0,   40,  329,
 363       171,    0,  759,  759,  759,  574,  759,  759,  171,  245,
 364       759,  336,  150,  219,  223,  226,  227,  162,  228,  262,
 365       263,  310,  266,  265,  313,  268,  312,  330,  320,  334,
 366       572,  569,  366,  377,  759,  380,  547,    0,  530,    0,
 367
 368       501,  169,  363,   46,  365,    0,  503,  386,  402,  417,
 369         0,  417,  335,  344,  412,  387,  360,  386,  406,  413,
 370       431,  407,  425,  408,  437,  438,  421,  518,    0,  472,
 371       497,  475,  474,  759,    0,  456,    0,  246,  458,  284,
 372       462,  451,  403,  464,  477,  478,  454,  408,  402,  392,
 373       390,  364,  376,  509,  455,  483,  458,  485,  473,  489,
 374       491,  492,  367,  759,  387,  516,  366,   48,  535,  326,
 375       312,  270,  220,  219,  207,  164,  501,  509,  511,  144,
 376       282,  527,   98,  117,  529,  519,   42,  540,  321,  543,
 377       562,  403,  548,  551,  759,  580,  590,  606,  611,  627,
 378
 379       644,  647,  654,  487,  562,  661,  677,  689,  695,  706,
 380       708,  724,  563,  565,  731,  742
 381     } ;
 382
 383 static yyconst short int yy_def[217] =
 384     {   0,
 385       195,    1,    1,    1,  195,  195,  195,  195,  196,  197,
 386       195,  195,  195,  195,  195,  195,  195,  198,  195,  195,
 387       195,  195,  199,  195,  195,  195,  200,  200,   28,   28,
 388        28,   28,   28,   28,   28,   28,   28,  195,  196,  195,
 389       196,  197,   38,   38,   38,   43,  195,   43,   43,  195,
 390       201,  198,  195,  202,  203,  203,  195,  204,  195,  195,
 391       195,  205,  195,  195,  195,  206,  195,  195,  195,  195,
 392       195,  207,   28,   28,   28,   28,   28,   28,   28,   28,
 393        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
 394        49,  208,  195,  195,  195,   43,   49,  201,  209,  203,
 395
 396       203,  210,  195,  195,  195,  205,  206,  195,  207,  195,
 397       211,  212,   28,   28,   28,   28,   28,   28,   28,   28,
 398        28,   28,   28,   28,   28,   28,   28,  195,  213,  195,
 399       195,   43,  209,  195,  203,  195,  214,  210,  195,  195,
 400       195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
 401       195,  195,  215,  212,   28,   28,   28,   28,   28,   28,
 402        28,   28,  195,  195,   43,  195,  216,  195,  195,  195,
 403       195,  195,  195,  195,  195,  215,   28,   28,   28,   43,
 404       195,  195,  195,  216,  195,   28,   43,  195,  195,  195,
 405       195,  195,  195,  195,    0,  195,  195,  195,  195,  195,
 406
 407       195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
 408       195,  195,  195,  195,  195,  195
 409     } ;
 410
 411 static yyconst short int yy_nxt[809] =
 412     {   0,
 413         6,    7,    8,    7,    6,    9,    6,   10,   11,   12,
 414        13,   14,   15,   11,   16,   17,   18,   19,   20,   21,
 415        22,   11,   23,   24,   25,   26,   11,   11,   27,   28,
 416        27,   27,   27,   29,   30,   27,   27,   31,   27,   27,
 417        32,   33,   34,   35,   27,   36,   27,   27,   37,   40,
 418        63,  191,   73,   64,   69,   69,   70,   73,  103,  103,
 419        86,   76,   71,   73,  105,  105,  185,  185,   73,   72,
 420        41,   43,   44,   44,   45,   46,   46,   46,   46,   46,
 421        47,   46,   46,   46,   46,   46,   46,   46,   46,   46,
 422        46,   46,   46,   46,   46,   46,   46,   48,   46,   46,
 423
 424        49,   49,   49,   49,   49,   49,   49,   49,   49,   49,
 425        49,   49,   49,   49,   49,   49,   49,   49,   49,   49,
 426        52,   52,   52,  183,   58,   96,   77,   73,   73,   94,
 427        58,  189,   78,   73,   59,   53,   60,   60,   73,   79,
 428        59,   54,   60,   60,   73,   80,   60,   73,   56,   73,
 429        81,   61,   60,   69,   69,   70,   40,   61,   73,   82,
 430        73,   71,   84,   83,   85,   92,   62,   73,   72,   87,
 431        73,  187,   69,   69,   69,  136,   88,   41,   73,   90,
 432        73,   73,   74,   89,  104,  137,   41,   72,  169,  105,
 433       105,   73,   73,   75,   43,   44,   44,   44,   43,   43,
 434
 435        43,   43,   43,   73,   43,   43,   43,   43,   43,   43,
 436        43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
 437        43,   43,   43,   91,   91,   91,   91,   91,   91,   91,
 438        91,   91,   91,   91,   91,   91,   91,   91,   91,   91,
 439        91,   91,   91,   43,   43,   43,   69,   69,   70,   73,
 440       142,   93,  136,   73,   71,  114,   73,   73,   73,  142,
 441        73,   72,  137,  113,   73,  142,  116,   73,   73,   73,
 442       115,   43,   43,   43,   43,   43,   43,   43,   43,   43,
 443        43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
 444        43,   94,   73,   73,  117,   73,   73,  168,   73,  168,
 445
 446       182,  182,  142,   73,   73,  120,   73,   73,  122,   73,
 447       118,   97,   97,   97,   97,   97,   97,   97,   97,   97,
 448        97,   97,   97,   97,   97,   97,   97,   97,   97,   97,
 449        97,   52,   52,   52,  192,   58,  192,  109,  109,  109,
 450        73,  110,   73,   73,  142,   59,  195,   60,   60,  121,
 451        73,   73,   54,   73,   73,  119,  123,   60,  111,   56,
 452        73,   73,   61,  124,   73,   73,  126,  130,  130,  130,
 453       142,   73,  183,  125,   73,   73,   73,  127,  130,  130,
 454       130,  139,  139,  141,  141,   73,  131,   69,   69,   70,
 455        73,  139,  180,  141,   39,   71,  140,  131,  132,  132,
 456
 457       169,   73,   72,  109,  109,  109,  175,  110,  169,  132,
 458       132,  132,  132,  132,  132,  142,   73,   73,   69,   69,
 459        70,  193,  193,  174,  111,  142,   71,   73,   73,  143,
 460       142,  156,  142,   72,  144,  142,   73,   73,   73,  145,
 461       142,  146,   73,   73,  173,  155,  147,   73,   73,  160,
 462       172,   73,  157,   73,   73,   73,  169,  148,  149,  150,
 463       151,   73,   73,  159,  158,  152,   73,   73,   73,  169,
 464       161,  162,   73,  130,  130,  130,  139,  139,   73,   73,
 465       141,  141,  169,  169,  170,   73,  139,  142,   73,  166,
 466       141,  140,  131,  165,  165,  171,   73,  102,  134,   73,
 467
 468       142,  142,  102,   73,  165,  165,  165,  165,  165,  165,
 469        69,   69,   70,   73,   73,   73,  177,  164,   71,   73,
 470       179,   73,   73,  163,   73,   72,   73,  108,  178,  181,
 471        73,   73,   73,   73,  182,  182,   69,   69,   70,   73,
 472       135,   73,   73,  159,   71,  188,  188,  190,  190,   73,
 473        73,   72,   73,  186,  134,  188,   93,  190,  188,  188,
 474        73,  190,  190,  130,  130,  130,  194,  194,  188,  194,
 475       194,  190,  106,  128,  128,  167,  194,  106,  128,  194,
 476       167,   93,  131,   39,   39,   39,   39,   39,   39,   39,
 477        39,   39,   39,   39,   39,   39,   39,   42,  108,  101,
 478
 479        42,   95,   94,   94,   42,   42,   42,   55,   55,   55,
 480        93,   68,   67,   65,   57,   55,   51,   55,   50,  195,
 481        55,   55,   55,   66,   38,   66,   66,   66,   73,   73,
 482        73,   38,  195,  195,  195,   73,   73,   73,  195,  195,
 483       195,   73,   73,   73,   98,   98,  195,   98,   98,   98,
 484        98,   98,   98,   98,   98,   98,   98,   98,   98,   98,
 485        98,   99,   99,   99,  100,  195,  195,  195,  100,  100,
 486       100,  107,  195,  195,  107,  107,  107,  107,  112,  112,
 487       112,  195,  112,  195,  195,  195,  195,  195,  112,  195,
 488       195,  112,  112,  112,  129,  195,  195,  195,  195,  129,
 489
 490       195,  195,  195,  195,  129,  133,  195,  195,  133,  133,
 491       133,  133,  138,  195,  195,  138,  138,  195,  195,  195,
 492       138,  138,  153,  153,  153,  154,  154,  154,  195,  195,
 493       195,  195,  154,  154,  154,  195,  195,  195,  154,  154,
 494       154,  176,  195,  195,  176,  176,  176,  176,  184,  195,
 495       195,  195,  184,  195,  195,  195,  184,  184,    5,  195,
 496       195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
 497       195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
 498       195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
 499       195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
 500
 501       195,  195,  195,  195,  195,  195,  195,  195
 502     } ;
 503
 504 static yyconst short int yy_chk[809] =
 505     {   0,
 506         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 507         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 508         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 509         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 510         1,    1,    1,    1,    1,    1,    1,    1,    1,    9,
 511        22,  187,   29,   22,   27,   27,   27,   35,   59,   59,
 512        35,   29,   27,   29,  104,  104,  168,  168,   35,   27,
 513         9,   12,   12,   12,   12,   12,   12,   12,   12,   12,
 514        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
 515        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
 516
 517        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
 518        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
 519        18,   18,   18,  184,   20,   48,   30,   30,   31,   48,
 520        21,  183,   31,   32,   20,   18,   20,   20,   30,   31,
 521        21,   18,   21,   21,   32,   32,   20,   33,   18,   34,
 522        33,   20,   21,   28,   28,   28,   39,   21,   33,   33,
 523        34,   28,   34,   33,   34,   41,   20,   37,   28,   36,
 524        36,  180,   69,   69,   69,  102,   36,   39,   37,   37,
 525        73,   36,   28,   36,   61,  102,   41,   69,  176,   61,
 526        61,   73,   78,   28,   38,   38,   38,   38,   38,   38,
 527
 528        38,   38,   38,   78,   38,   38,   38,   38,   38,   38,
 529        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
 530        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
 531        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
 532        38,   38,   38,   43,   43,   43,   70,   70,   70,   74,
 533       175,   43,  138,   75,   70,   75,   76,   77,   79,  174,
 534        74,   70,  138,   74,   75,  173,   77,   76,   77,   79,
 535        76,   43,   43,   43,   43,   43,   43,   43,   43,   43,
 536        43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
 537        43,   49,   80,   81,   80,   84,   83,  140,   86,  140,
 538
 539       181,  181,  172,   80,   81,   83,   84,   83,   86,   86,
 540        81,   49,   49,   49,   49,   49,   49,   49,   49,   49,
 541        49,   49,   49,   49,   49,   49,   49,   49,   49,   49,
 542        49,   52,   52,   52,  189,   60,  189,   72,   72,   72,
 543        82,   72,   87,   85,  171,   60,   52,   60,   60,   85,
 544        89,   82,   52,   87,   85,   82,   87,   60,   72,   52,
 545        88,   89,   60,   88,   90,  113,   89,   93,   93,   93,
 546       170,   88,  167,   88,  114,   90,  113,   90,   94,   94,
 547        94,  103,  103,  105,  105,  114,   93,  108,  108,  108,
 548       117,  103,  165,  105,  163,  108,  103,   94,   96,   96,
 549
 550       153,  117,  108,  109,  109,  109,  152,  109,  143,   96,
 551        96,   96,   96,   96,   96,  143,  118,  116,  112,  112,
 552       112,  192,  192,  151,  109,  110,  112,  118,  116,  110,
 553       110,  116,  110,  112,  110,  150,  119,  122,  124,  110,
 554       110,  110,  115,  120,  149,  115,  110,  119,  122,  124,
 555       148,  127,  120,  115,  120,  123,  142,  110,  110,  110,
 556       110,  121,  127,  123,  121,  110,  123,  125,  126,  144,
 557       125,  126,  121,  130,  130,  130,  139,  139,  125,  126,
 558       141,  141,  145,  146,  147,  155,  139,  144,  157,  136,
 559       141,  139,  130,  132,  132,  147,  155,  204,  133,  157,
 560
 561       145,  146,  204,  159,  132,  132,  132,  132,  132,  132,
 562       154,  154,  154,  156,  159,  158,  156,  131,  154,  160,
 563       161,  161,  162,  128,  156,  154,  158,  107,  158,  166,
 564       160,  177,  161,  162,  166,  166,  169,  169,  169,  178,
 565       101,  179,  177,  179,  169,  182,  182,  185,  185,  186,
 566       178,  169,  179,  178,   99,  182,   97,  185,  188,  188,
 567       186,  190,  190,  191,  191,  191,  193,  193,  188,  194,
 568       194,  190,  205,  213,   92,  214,  193,  205,  213,  194,
 569       214,   91,  191,  196,  196,  196,  196,  196,  196,  196,
 570       196,  196,  196,  196,  196,  196,  196,  197,   66,   56,
 571
 572       197,   47,   46,   45,  197,  197,  197,  198,  198,  198,
 573        44,   25,   24,   23,   19,  198,   17,  198,   15,    5,
 574       198,  198,  198,  199,    4,  199,  199,  199,  200,  200,
 575       200,    3,    0,    0,    0,  200,  200,  200,    0,    0,
 576         0,  200,  200,  200,  201,  201,    0,  201,  201,  201,
 577       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 578       201,  202,  202,  202,  203,    0,    0,    0,  203,  203,
 579       203,  206,    0,    0,  206,  206,  206,  206,  207,  207,
 580       207,    0,  207,    0,    0,    0,    0,    0,  207,    0,
 581         0,  207,  207,  207,  208,    0,    0,    0,    0,  208,
 582
 583         0,    0,    0,    0,  208,  209,    0,    0,  209,  209,
 584       209,  209,  210,    0,    0,  210,  210,    0,    0,    0,
 585       210,  210,  211,  211,  211,  212,  212,  212,    0,    0,
 586         0,    0,  212,  212,  212,    0,    0,    0,  212,  212,
 587       212,  215,    0,    0,  215,  215,  215,  215,  216,    0,
 588         0,    0,  216,    0,    0,    0,  216,  216,  195,  195,
 589       195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
 590       195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
 591       195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
 592       195,  195,  195,  195,  195,  195,  195,  195,  195,  195,
 593
 594       195,  195,  195,  195,  195,  195,  195,  195
 595     } ;
 596
 597 static yy_state_type yy_last_accepting_state;
 598 static char *yy_last_accepting_cpos;
 599
 600 /* The intent behind this definition is that it'll catch
 601  * any uses of REJECT which flex missed.
 602  */
 603 #define REJECT reject_used_but_not_detected
 604 #define yymore() yymore_used_but_not_detected
 605 #define YY_MORE_ADJ 0
 606 #define YY_RESTORE_YY_MORE_OFFSET
 607 char *yytext;
 608 #line 1 "ada-lex.l"
 609 #define INITIAL 0
 610 /* FLEX lexer for Ada expressions, for GDB.
 611    Copyright (C) 1994, 1997, 1998, 2000, 2001, 2002, 2003, 2007, 2008, 2009,
 612    2010 Free Software Foundation, Inc.
 613
 614    This file is part of GDB.
 615
 616    This program is free software; you can redistribute it and/or modify
 617    it under the terms of the GNU General Public License as published by
 618    the Free Software Foundation; either version 3 of the License, or
 619    (at your option) any later version.
 620
 621    This program is distributed in the hope that it will be useful,
 622    but WITHOUT ANY WARRANTY; without even the implied warranty of
 623    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 624    GNU General Public License for more details.
 625
 626    You should have received a copy of the GNU General Public License
 627    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 628 /*----------------------------------------------------------------------*/
 629 /* The converted version of this file is to be included in ada-exp.y, */
 630 /* the Ada parser for gdb.  The function yylex obtains characters from */
 631 /* the global pointer lexptr.  It returns a syntactic category for */
 632 /* each successive token and places a semantic value into yylval */
 633 /* (ada-lval), defined by the parser.   */
 634 #line 44 "ada-lex.l"
 635
 636 #define NUMERAL_WIDTH 256
 637 #define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
 638
 639 /* Temporary staging for numeric literals.  */
 640 static char numbuf[NUMERAL_WIDTH];
 641  static void canonicalizeNumeral (char *s1, const char *);
 642 static struct stoken processString (const char*, int);
 643 static int processInt (const char *, const char *, const char *);
 644 static int processReal (const char *);
 645 static struct stoken processId (const char *, int);
 646 static int processAttribute (const char *);
 647 static int find_dot_all (const char *);
 648
 649 #undef YY_DECL
 650 #define YY_DECL static int yylex ( void )
 651
 652 /* Flex generates a static function "input" which is not used.
 653    Defining YY_NO_INPUT comments it out.  */
 654 #define YY_NO_INPUT
 655
 656 #undef YY_INPUT
 657 #define YY_INPUT(BUF, RESULT, MAX_SIZE) \
 658     if ( *lexptr == '\000' ) \
 659       (RESULT) = YY_NULL; \
 660     else \
 661       { \
 662         *(BUF) = *lexptr; \
 663         (RESULT) = 1; \
 664         lexptr += 1; \
 665       }
 666
 667 static int find_dot_all (const char *);
 668
 669 #define BEFORE_QUAL_QUOTE 1
 670
 671 #line 672 "ada-lex.c"
 672
 673 /* Macros after this point can all be overridden by user definitions in
 674  * section 1.
 675  */
 676
 677 #ifndef YY_SKIP_YYWRAP
 678 #ifdef __cplusplus
 679 extern "C" int yywrap YY_PROTO(( void ));
 680 #else
 681 extern int yywrap YY_PROTO(( void ));
 682 #endif
 683 #endif
 684
 685 #ifndef YY_NO_UNPUT
 686 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
 687 #endif
 688
 689 #ifndef yytext_ptr
 690 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 691 #endif
 692
 693 #ifdef YY_NEED_STRLEN
 694 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 695 #endif
 696
 697 #ifndef YY_NO_INPUT
 698 #ifdef __cplusplus
 699 static int yyinput YY_PROTO(( void ));
 700 #else
 701 static int input YY_PROTO(( void ));
 702 #endif
 703 #endif
 704
 705 #if YY_STACK_USED
 706 static int yy_start_stack_ptr = 0;
 707 static int yy_start_stack_depth = 0;
 708 static int *yy_start_stack = 0;
 709 #ifndef YY_NO_PUSH_STATE
 710 static void yy_push_state YY_PROTO(( int new_state ));
 711 #endif
 712 #ifndef YY_NO_POP_STATE
 713 static void yy_pop_state YY_PROTO(( void ));
 714 #endif
 715 #ifndef YY_NO_TOP_STATE
 716 static int yy_top_state YY_PROTO(( void ));
 717 #endif
 718
 719 #else
 720 #define YY_NO_PUSH_STATE 1
 721 #define YY_NO_POP_STATE 1
 722 #define YY_NO_TOP_STATE 1
 723 #endif
 724
 725 #ifdef YY_MALLOC_DECL
 726 YY_MALLOC_DECL
 727 #else
 728 #if __STDC__
 729 #ifndef __cplusplus
 730 #include <stdlib.h>
 731 #endif
 732 #else
 733 /* Just try to get by without declaring the routines.  This will fail
 734  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 735  * or sizeof(void*) != sizeof(int).
 736  */
 737 #endif
 738 #endif
 739
 740 /* Amount of stuff to slurp up with each read. */
 741 #ifndef YY_READ_BUF_SIZE
 742 #define YY_READ_BUF_SIZE 8192
 743 #endif
 744
 745 /* Copy whatever the last rule matched to the standard output. */
 746
 747 #ifndef ECHO
 748 /* This used to be an fputs(), but since the string might contain NUL's,
 749  * we now use fwrite().
 750  */
 751 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 752 #endif
 753
 754 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 755  * is returned in "result".
 756  */
 757 #ifndef YY_INPUT
 758 #define YY_INPUT(buf,result,max_size) \
 759         if ( yy_current_buffer->yy_is_interactive ) \
 760                 { \
 761                 int c = '*', n; \
 762                 for ( n = 0; n < max_size && \
 763                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 764                         buf[n] = (char) c; \
 765                 if ( c == '\n' ) \
 766                         buf[n++] = (char) c; \
 767                 if ( c == EOF && ferror( yyin ) ) \
 768                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 769                 result = n; \
 770                 } \
 771         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
 772                   && ferror( yyin ) ) \
 773                 YY_FATAL_ERROR( "input in flex scanner failed" );
 774 #endif
 775
 776 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 777  * we don't want an extra ';' after the "return" because that will cause
 778  * some compilers to complain about unreachable statements.
 779  */
 780 #ifndef yyterminate
 781 #define yyterminate() return YY_NULL
 782 #endif
 783
 784 /* Number of entries by which start-condition stack grows. */
 785 #ifndef YY_START_STACK_INCR
 786 #define YY_START_STACK_INCR 25
 787 #endif
 788
 789 /* Report a fatal error. */
 790 #ifndef YY_FATAL_ERROR
 791 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 792 #endif
 793
 794 /* Default declaration of generated scanner - a define so the user can
 795  * easily add parameters.
 796  */
 797 #ifndef YY_DECL
 798 #define YY_DECL int yylex YY_PROTO(( void ))
 799 #endif
 800
 801 /* Code executed at the beginning of each rule, after yytext and yyleng
 802  * have been set up.
 803  */
 804 #ifndef YY_USER_ACTION
 805 #define YY_USER_ACTION
 806 #endif
 807
 808 /* Code executed at the end of each rule. */
 809 #ifndef YY_BREAK
 810 #define YY_BREAK break;
 811 #endif
 812
 813 #define YY_RULE_SETUP \
 814         YY_USER_ACTION
 815
 816 YY_DECL
 817         {
 818         register yy_state_type yy_current_state;
 819         register char *yy_cp = NULL, *yy_bp = NULL;
 820         register int yy_act;
 821
 822 #line 84 "ada-lex.l"
 823
 824
 825 #line 826 "ada-lex.c"
 826
 827         if ( yy_init )
 828                 {
 829                 yy_init = 0;
 830
 831 #ifdef YY_USER_INIT
 832                 YY_USER_INIT;
 833 #endif
 834
 835                 if ( ! yy_start )
 836                         yy_start = 1;   /* first start state */
 837
 838                 if ( ! yyin )
 839                         yyin = stdin;
 840
 841                 if ( ! yyout )
 842                         yyout = stdout;
 843
 844                 if ( ! yy_current_buffer )
 845                         yy_current_buffer =
 846                                 yy_create_buffer( yyin, YY_BUF_SIZE );
 847
 848                 yy_load_buffer_state();
 849                 }
 850
 851         while ( 1 )             /* loops until end-of-file is reached */
 852                 {
 853                 yy_cp = yy_c_buf_p;
 854
 855                 /* Support of yytext. */
 856                 *yy_cp = yy_hold_char;
 857
 858                 /* yy_bp points to the position in yy_ch_buf of the start of
 859                  * the current run.
 860                  */
 861                 yy_bp = yy_cp;
 862
 863                 yy_current_state = yy_start;
 864 yy_match:
 865                 do
 866                         {
 867                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 868                         if ( yy_accept[yy_current_state] )
 869                                 {
 870                                 yy_last_accepting_state = yy_current_state;
 871                                 yy_last_accepting_cpos = yy_cp;
 872                                 }
 873                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 874                                 {
 875                                 yy_current_state = (int) yy_def[yy_current_state];
 876                                 if ( yy_current_state >= 196 )
 877                                         yy_c = yy_meta[(unsigned int) yy_c];
 878                                 }
 879                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 880                         ++yy_cp;
 881                         }
 882                 while ( yy_base[yy_current_state] != 759 );
 883
 884 yy_find_action:
 885                 yy_act = yy_accept[yy_current_state];
 886                 if ( yy_act == 0 )
 887                         { /* have to back up */
 888                         yy_cp = yy_last_accepting_cpos;
 889                         yy_current_state = yy_last_accepting_state;
 890                         yy_act = yy_accept[yy_current_state];
 891                         }
 892
 893                 YY_DO_BEFORE_ACTION;
 894
 895
 896 do_action:      /* This label is used only to access EOF actions. */
 897
 898
 899                 switch ( yy_act )
 900         { /* beginning of action switch */
 901                         case 0: /* must back up */
 902                         /* undo the effects of YY_DO_BEFORE_ACTION */
 903                         *yy_cp = yy_hold_char;
 904                         yy_cp = yy_last_accepting_cpos;
 905                         yy_current_state = yy_last_accepting_state;
 906                         goto yy_find_action;
 907
 908 case 1:
 909 YY_RULE_SETUP
 910 #line 86 "ada-lex.l"
 911 { }
 912         YY_BREAK
 913 case 2:
 914 YY_RULE_SETUP
 915 #line 88 "ada-lex.l"
 916 { yyterminate(); }
 917         YY_BREAK
 918 case 3:
 919 YY_RULE_SETUP
 920 #line 90 "ada-lex.l"
 921 {
 922                    canonicalizeNumeral (numbuf, yytext);
 923                    return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1);
 924                  }
 925         YY_BREAK
 926 case 4:
 927 YY_RULE_SETUP
 928 #line 95 "ada-lex.l"
 929 {
 930                    canonicalizeNumeral (numbuf, yytext);
 931                    return processInt (NULL, numbuf, NULL);
 932                  }
 933         YY_BREAK
 934 case 5:
 935 YY_RULE_SETUP
 936 #line 100 "ada-lex.l"
 937 {
 938                    canonicalizeNumeral (numbuf, yytext);
 939                    return processInt (numbuf,
 940                                       strchr (numbuf, '#') + 1,
 941                                       strrchr(numbuf, '#') + 1);
 942                  }
 943         YY_BREAK
 944 case 6:
 945 YY_RULE_SETUP
 946 #line 107 "ada-lex.l"
 947 {
 948                    canonicalizeNumeral (numbuf, yytext);
 949                    return processInt (numbuf, strchr (numbuf, '#') + 1, NULL);
 950                  }
 951         YY_BREAK
 952 case 7:
 953 YY_RULE_SETUP
 954 #line 112 "ada-lex.l"
 955 {
 956                   canonicalizeNumeral (numbuf, yytext+2);
 957                   return processInt ("16#", numbuf, NULL);
 958                 }
 959         YY_BREAK
 960 case 8:
 961 YY_RULE_SETUP
 962 #line 118 "ada-lex.l"
 963 {
 964                    canonicalizeNumeral (numbuf, yytext);
 965                    return processReal (numbuf);
 966                 }
 967         YY_BREAK
 968 case 9:
 969 YY_RULE_SETUP
 970 #line 123 "ada-lex.l"
 971 {
 972                    canonicalizeNumeral (numbuf, yytext);
 973                    return processReal (numbuf);
 974                 }
 975         YY_BREAK
 976 case 10:
 977 YY_RULE_SETUP
 978 #line 128 "ada-lex.l"
 979 {
 980                    error (_("Based real literals not implemented yet."));
 981                 }
 982         YY_BREAK
 983 case 11:
 984 YY_RULE_SETUP
 985 #line 132 "ada-lex.l"
 986 {
 987                    error (_("Based real literals not implemented yet."));
 988                 }
 989         YY_BREAK
 990 case 12:
 991 YY_RULE_SETUP
 992 #line 136 "ada-lex.l"
 993 {
 994                    yylval.typed_val.type = type_char ();
 995                    yylval.typed_val.val = yytext[1];
 996                    return CHARLIT;
 997                 }
 998         YY_BREAK
 999 case 13:
1000 YY_RULE_SETUP
1001 #line 142 "ada-lex.l"
1002 {
1003                    int v;
1004                    yylval.typed_val.type = type_char ();
1005                    sscanf (yytext+3, "%2x", &v);
1006                    yylval.typed_val.val = v;
1007                    return CHARLIT;
1008                 }
1009         YY_BREAK
1010 case 14:
1011 YY_RULE_SETUP
1012 #line 150 "ada-lex.l"
1013 {
1014                    yylval.sval = processString (yytext+1, yyleng-2);
1015                    return STRING;
1016                 }
1017         YY_BREAK
1018 case 15:
1019 YY_RULE_SETUP
1020 #line 155 "ada-lex.l"
1021 {
1022                    error (_("ill-formed or non-terminated string literal"));
1023                 }
1024         YY_BREAK
1025 case 16:
1026 YY_RULE_SETUP
1027 #line 160 "ada-lex.l"
1028 {
1029                   while (*lexptr != 'i' && *lexptr != 'I')
1030                     lexptr -= 1;
1031                   yyrestart(NULL);
1032                   return 0;
1033                 }
1034         YY_BREAK
1035 case 17:
1036 YY_RULE_SETUP
1037 #line 167 "ada-lex.l"
1038 {
1039                   /* This keyword signals the end of the expression and
1040                      will be processed separately.  */
1041                   while (*lexptr != 't' && *lexptr != 'T')
1042                     lexptr--;
1043                   yyrestart(NULL);
1044                   return 0;
1045                 }
1046         YY_BREAK
1047 /* ADA KEYWORDS */
1048 case 18:
1049 YY_RULE_SETUP
1050 #line 178 "ada-lex.l"
1051 { return ABS; }
1052         YY_BREAK
1053 case 19:
1054 YY_RULE_SETUP
1055 #line 179 "ada-lex.l"
1056 { return _AND_; }
1057         YY_BREAK
1058 case 20:
1059 YY_RULE_SETUP
1060 #line 180 "ada-lex.l"
1061 { return ELSE; }
1062         YY_BREAK
1063 case 21:
1064 YY_RULE_SETUP
1065 #line 181 "ada-lex.l"
1066 { return IN; }
1067         YY_BREAK
1068 case 22:
1069 YY_RULE_SETUP
1070 #line 182 "ada-lex.l"
1071 { return MOD; }
1072         YY_BREAK
1073 case 23:
1074 YY_RULE_SETUP
1075 #line 183 "ada-lex.l"
1076 { return NEW; }
1077         YY_BREAK
1078 case 24:
1079 YY_RULE_SETUP
1080 #line 184 "ada-lex.l"
1081 { return NOT; }
1082         YY_BREAK
1083 case 25:
1084 YY_RULE_SETUP
1085 #line 185 "ada-lex.l"
1086 { return NULL_PTR; }
1087         YY_BREAK
1088 case 26:
1089 YY_RULE_SETUP
1090 #line 186 "ada-lex.l"
1091 { return OR; }
1092         YY_BREAK
1093 case 27:
1094 YY_RULE_SETUP
1095 #line 187 "ada-lex.l"
1096 { return OTHERS; }
1097         YY_BREAK
1098 case 28:
1099 YY_RULE_SETUP
1100 #line 188 "ada-lex.l"
1101 { return REM; }
1102         YY_BREAK
1103 case 29:
1104 YY_RULE_SETUP
1105 #line 189 "ada-lex.l"
1106 { return THEN; }
1107         YY_BREAK
1108 case 30:
1109 YY_RULE_SETUP
1110 #line 190 "ada-lex.l"
1111 { return XOR; }
1112         YY_BREAK
1113 /* BOOLEAN "KEYWORDS" */
1114 /* True and False are not keywords in Ada, but rather enumeration constants.
1115     However, the boolean type is no longer represented as an enum, so True
1116     and False are no longer defined in symbol tables.  We compromise by
1117     making them keywords (when bare). */
1118 case 31:
1119 YY_RULE_SETUP
1120 #line 199 "ada-lex.l"
1121 { return TRUEKEYWORD; }
1122         YY_BREAK
1123 case 32:
1124 YY_RULE_SETUP
1125 #line 200 "ada-lex.l"
1126 { return FALSEKEYWORD; }
1127         YY_BREAK
1128 /* ATTRIBUTES */
1129 case 33:
1130 YY_RULE_SETUP
1131 #line 204 "ada-lex.l"
1132 { return processAttribute (yytext+1); }
1133         YY_BREAK
1134 /* PUNCTUATION */
1135 case 34:
1136 YY_RULE_SETUP
1137 #line 208 "ada-lex.l"
1138 { return ARROW; }
1139         YY_BREAK
1140 case 35:
1141 YY_RULE_SETUP
1142 #line 209 "ada-lex.l"
1143 { return DOTDOT; }
1144         YY_BREAK
1145 case 36:
1146 YY_RULE_SETUP
1147 #line 210 "ada-lex.l"
1148 { return STARSTAR; }
1149         YY_BREAK
1150 case 37:
1151 YY_RULE_SETUP
1152 #line 211 "ada-lex.l"
1153 { return ASSIGN; }
1154         YY_BREAK
1155 case 38:
1156 YY_RULE_SETUP
1157 #line 212 "ada-lex.l"
1158 { return NOTEQUAL; }
1159         YY_BREAK
1160 case 39:
1161 YY_RULE_SETUP
1162 #line 213 "ada-lex.l"
1163 { return LEQ; }
1164         YY_BREAK
1165 case 40:
1166 YY_RULE_SETUP
1167 #line 214 "ada-lex.l"
1168 { return GEQ; }
1169         YY_BREAK
1170 case 41:
1171 YY_RULE_SETUP
1172 #line 216 "ada-lex.l"
1173 { BEGIN INITIAL; return '\''; }
1174         YY_BREAK
1175 case 42:
1176 YY_RULE_SETUP
1177 #line 218 "ada-lex.l"
1178 { return yytext[0]; }
1179         YY_BREAK
1180 case 43:
1181 YY_RULE_SETUP
1182 #line 220 "ada-lex.l"
1183 { if (paren_depth == 0 && comma_terminates)
1184                     {
1185                       lexptr -= 1;
1186                       yyrestart(NULL);
1187                       return 0;
1188                     }
1189                   else
1190                     return ',';
1191                 }
1192         YY_BREAK
1193 case 44:
1194 YY_RULE_SETUP
1195 #line 230 "ada-lex.l"
1196 { paren_depth += 1; return '('; }
1197         YY_BREAK
1198 case 45:
1199 YY_RULE_SETUP
1200 #line 231 "ada-lex.l"
1201 { if (paren_depth == 0)
1202                     {
1203                       lexptr -= 1;
1204                       yyrestart(NULL);
1205                       return 0;
1206                     }
1207                   else
1208                     {
1209                       paren_depth -= 1;
1210                       return ')';
1211                     }
1212                 }
1213         YY_BREAK
1214 case 46:
1215 YY_RULE_SETUP
1216 #line 244 "ada-lex.l"
1217 { return DOT_ALL; }
1218         YY_BREAK
1219 case 47:
1220 YY_RULE_SETUP
1221 #line 246 "ada-lex.l"
1222 {
1223                   yylval.sval = processId (yytext+1, yyleng-1);
1224                   return DOT_ID;
1225                 }
1226         YY_BREAK
1227 case 48:
1228 YY_RULE_SETUP
1229 #line 251 "ada-lex.l"
1230 {
1231                   int all_posn = find_dot_all (yytext);
1232
1233                   if (all_posn == -1 && yytext[yyleng-1] == '\'')
1234                     {
1235                       BEGIN BEFORE_QUAL_QUOTE;
1236                       yyless (yyleng-1);
1237                     }
1238                   else if (all_posn >= 0)
1239                     yyless (all_posn);
1240                   yylval.sval = processId (yytext, yyleng);
1241                   return NAME;
1242                }
1243         YY_BREAK
1244 /* GDB EXPRESSION CONSTRUCTS  */
1245 case 49:
1246 YY_RULE_SETUP
1247 #line 268 "ada-lex.l"
1248 {
1249                   yyless (yyleng - 2);
1250                   yylval.sval = processId (yytext, yyleng);
1251                   return NAME;
1252                 }
1253         YY_BREAK
1254 case 50:
1255 YY_RULE_SETUP
1256 #line 274 "ada-lex.l"
1257 { return COLONCOLON; }
1258         YY_BREAK
1259 case 51:
1260 YY_RULE_SETUP
1261 #line 276 "ada-lex.l"
1262 { return yytext[0]; }
1263         YY_BREAK
1264 /* REGISTERS AND GDB CONVENIENCE VARIABLES */
1265 case 52:
1266 YY_RULE_SETUP
1267 #line 280 "ada-lex.l"
1268 {
1269                   yylval.sval.ptr = yytext;
1270                   yylval.sval.length = yyleng;
1271                   return SPECIAL_VARIABLE;
1272                 }
1273         YY_BREAK
1274 /* CATCH-ALL ERROR CASE */
1275 case 53:
1276 YY_RULE_SETUP
1277 #line 288 "ada-lex.l"
1278 { error (_("Invalid character '%s' in expression."), yytext); }
1279         YY_BREAK
1280 case 54:
1281 YY_RULE_SETUP
1282 #line 289 "ada-lex.l"
1283 YY_FATAL_ERROR( "flex scanner jammed" );
1284         YY_BREAK
1285 #line 1286 "ada-lex.c"
1286 case YY_STATE_EOF(INITIAL):
1287 case YY_STATE_EOF(BEFORE_QUAL_QUOTE):
1288         yyterminate();
1289
1290         case YY_END_OF_BUFFER:
1291                 {
1292                 /* Amount of text matched not including the EOB char. */
1293                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1294
1295                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1296                 *yy_cp = yy_hold_char;
1297                 YY_RESTORE_YY_MORE_OFFSET
1298
1299                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1300                         {
1301                         /* We're scanning a new file or input source.  It's
1302                          * possible that this happened because the user
1303                          * just pointed yyin at a new source and called
1304                          * yylex().  If so, then we have to assure
1305                          * consistency between yy_current_buffer and our
1306                          * globals.  Here is the right place to do so, because
1307                          * this is the first action (other than possibly a
1308                          * back-up) that will match for the new input source.
1309                          */
1310                         yy_n_chars = yy_current_buffer->yy_n_chars;
1311                         yy_current_buffer->yy_input_file = yyin;
1312                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1313                         }
1314
1315                 /* Note that here we test for yy_c_buf_p "<=" to the position
1316                  * of the first EOB in the buffer, since yy_c_buf_p will
1317                  * already have been incremented past the NUL character
1318                  * (since all states make transitions on EOB to the
1319                  * end-of-buffer state).  Contrast this with the test
1320                  * in input().
1321                  */
1322                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1323                         { /* This was really a NUL. */
1324                         yy_state_type yy_next_state;
1325
1326                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1327
1328                         yy_current_state = yy_get_previous_state();
1329
1330                         /* Okay, we're now positioned to make the NUL
1331                          * transition.  We couldn't have
1332                          * yy_get_previous_state() go ahead and do it
1333                          * for us because it doesn't know how to deal
1334                          * with the possibility of jamming (and we don't
1335                          * want to build jamming into it because then it
1336                          * will run more slowly).
1337                          */
1338
1339                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1340
1341                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1342
1343                         if ( yy_next_state )
1344                                 {
1345                                 /* Consume the NUL. */
1346                                 yy_cp = ++yy_c_buf_p;
1347                                 yy_current_state = yy_next_state;
1348                                 goto yy_match;
1349                                 }
1350
1351                         else
1352                                 {
1353                                 yy_cp = yy_c_buf_p;
1354                                 goto yy_find_action;
1355                                 }
1356                         }
1357
1358                 else switch ( yy_get_next_buffer() )
1359                         {
1360                         case EOB_ACT_END_OF_FILE:
1361                                 {
1362                                 yy_did_buffer_switch_on_eof = 0;
1363
1364                                 if ( yywrap() )
1365                                         {
1366                                         /* Note: because we've taken care in
1367                                          * yy_get_next_buffer() to have set up
1368                                          * yytext, we can now set up
1369                                          * yy_c_buf_p so that if some total
1370                                          * hoser (like flex itself) wants to
1371                                          * call the scanner after we return the
1372                                          * YY_NULL, it'll still work - another
1373                                          * YY_NULL will get returned.
1374                                          */
1375                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1376
1377                                         yy_act = YY_STATE_EOF(YY_START);
1378                                         goto do_action;
1379                                         }
1380
1381                                 else
1382                                         {
1383                                         if ( ! yy_did_buffer_switch_on_eof )
1384                                                 YY_NEW_FILE;
1385                                         }
1386                                 break;
1387                                 }
1388
1389                         case EOB_ACT_CONTINUE_SCAN:
1390                                 yy_c_buf_p =
1391                                         yytext_ptr + yy_amount_of_matched_text;
1392
1393                                 yy_current_state = yy_get_previous_state();
1394
1395                                 yy_cp = yy_c_buf_p;
1396                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1397                                 goto yy_match;
1398
1399                         case EOB_ACT_LAST_MATCH:
1400                                 yy_c_buf_p =
1401                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1402
1403                                 yy_current_state = yy_get_previous_state();
1404
1405                                 yy_cp = yy_c_buf_p;
1406                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1407                                 goto yy_find_action;
1408                         }
1409                 break;
1410                 }
1411
1412         default:
1413                 YY_FATAL_ERROR(
1414                         "fatal flex scanner internal error--no action found" );
1415         } /* end of action switch */
1416                 } /* end of scanning one token */
1417         } /* end of yylex */
1418
1419
1420 /* yy_get_next_buffer - try to read in a new buffer
1421  *
1422  * Returns a code representing an action:
1423  *      EOB_ACT_LAST_MATCH -
1424  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1425  *      EOB_ACT_END_OF_FILE - end of file
1426  */
1427
1428 static int yy_get_next_buffer()
1429         {
1430         register char *dest = yy_current_buffer->yy_ch_buf;
1431         register char *source = yytext_ptr;
1432         register int number_to_move, i;
1433         int ret_val;
1434
1435         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1436                 YY_FATAL_ERROR(
1437                 "fatal flex scanner internal error--end of buffer missed" );
1438
1439         if ( yy_current_buffer->yy_fill_buffer == 0 )
1440                 { /* Don't try to fill the buffer, so this is an EOF. */
1441                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1442                         {
1443                         /* We matched a single character, the EOB, so
1444                          * treat this as a final EOF.
1445                          */
1446                         return EOB_ACT_END_OF_FILE;
1447                         }
1448
1449                 else
1450                         {
1451                         /* We matched some text prior to the EOB, first
1452                          * process it.
1453                          */
1454                         return EOB_ACT_LAST_MATCH;
1455                         }
1456                 }
1457
1458         /* Try to read more data. */
1459
1460         /* First move last chars to start of buffer. */
1461         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1462
1463         for ( i = 0; i < number_to_move; ++i )
1464                 *(dest++) = *(source++);
1465
1466         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1467                 /* don't do the read, it's not guaranteed to return an EOF,
1468                  * just force an EOF
1469                  */
1470                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1471
1472         else
1473                 {
1474                 int num_to_read =
1475                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1476
1477                 while ( num_to_read <= 0 )
1478                         { /* Not enough room in the buffer - grow it. */
1479 #ifdef YY_USES_REJECT
1480                         YY_FATAL_ERROR(
1481 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1482 #else
1483
1484                         /* just a shorter name for the current buffer */
1485                         YY_BUFFER_STATE b = yy_current_buffer;
1486
1487                         int yy_c_buf_p_offset =
1488                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1489
1490                         if ( b->yy_is_our_buffer )
1491                                 {
1492                                 int new_size = b->yy_buf_size * 2;
1493
1494                                 if ( new_size <= 0 )
1495                                         b->yy_buf_size += b->yy_buf_size / 8;
1496                                 else
1497                                         b->yy_buf_size *= 2;
1498
1499                                 b->yy_ch_buf = (char *)
1500                                         /* Include room in for 2 EOB chars. */
1501                                         yyxrealloc( (void *) b->yy_ch_buf,
1502                                                          b->yy_buf_size + 2 );
1503                                 }
1504                         else
1505                                 /* Can't grow it, we don't own it. */
1506                                 b->yy_ch_buf = 0;
1507
1508                         if ( ! b->yy_ch_buf )
1509                                 YY_FATAL_ERROR(
1510                                 "fatal error - scanner input buffer overflow" );
1511
1512                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1513
1514                         num_to_read = yy_current_buffer->yy_buf_size -
1515                                                 number_to_move - 1;
1516 #endif
1517                         }
1518
1519                 if ( num_to_read > YY_READ_BUF_SIZE )
1520                         num_to_read = YY_READ_BUF_SIZE;
1521
1522                 /* Read in more data. */
1523                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1524                         yy_n_chars, num_to_read );
1525
1526                 yy_current_buffer->yy_n_chars = yy_n_chars;
1527                 }
1528
1529         if ( yy_n_chars == 0 )
1530                 {
1531                 if ( number_to_move == YY_MORE_ADJ )
1532                         {
1533                         ret_val = EOB_ACT_END_OF_FILE;
1534                         yyrestart( yyin );
1535                         }
1536
1537                 else
1538                         {
1539                         ret_val = EOB_ACT_LAST_MATCH;
1540                         yy_current_buffer->yy_buffer_status =
1541                                 YY_BUFFER_EOF_PENDING;
1542                         }
1543                 }
1544
1545         else
1546                 ret_val = EOB_ACT_CONTINUE_SCAN;
1547
1548         yy_n_chars += number_to_move;
1549         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1550         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1551
1552         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1553
1554         return ret_val;
1555         }
1556
1557
1558 /* yy_get_previous_state - get the state just before the EOB char was reached */
1559
1560 static yy_state_type yy_get_previous_state()
1561         {
1562         register yy_state_type yy_current_state;
1563         register char *yy_cp;
1564
1565         yy_current_state = yy_start;
1566
1567         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1568                 {
1569                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1570                 if ( yy_accept[yy_current_state] )
1571                         {
1572                         yy_last_accepting_state = yy_current_state;
1573                         yy_last_accepting_cpos = yy_cp;
1574                         }
1575                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1576                         {
1577                         yy_current_state = (int) yy_def[yy_current_state];
1578                         if ( yy_current_state >= 196 )
1579                                 yy_c = yy_meta[(unsigned int) yy_c];
1580                         }
1581                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1582                 }
1583
1584         return yy_current_state;
1585         }
1586
1587
1588 /* yy_try_NUL_trans - try to make a transition on the NUL character
1589  *
1590  * synopsis
1591  *      next_state = yy_try_NUL_trans( current_state );
1592  */
1593
1594 #ifdef YY_USE_PROTOS
1595 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1596 #else
1597 static yy_state_type yy_try_NUL_trans( yy_current_state )
1598 yy_state_type yy_current_state;
1599 #endif
1600         {
1601         register int yy_is_jam;
1602         register char *yy_cp = yy_c_buf_p;
1603
1604         register YY_CHAR yy_c = 1;
1605         if ( yy_accept[yy_current_state] )
1606                 {
1607                 yy_last_accepting_state = yy_current_state;
1608                 yy_last_accepting_cpos = yy_cp;
1609                 }
1610         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1611                 {
1612                 yy_current_state = (int) yy_def[yy_current_state];
1613                 if ( yy_current_state >= 196 )
1614                         yy_c = yy_meta[(unsigned int) yy_c];
1615                 }
1616         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1617         yy_is_jam = (yy_current_state == 195);
1618
1619         return yy_is_jam ? 0 : yy_current_state;
1620         }
1621
1622
1623 #ifndef YY_NO_UNPUT
1624 #ifdef YY_USE_PROTOS
1625 static void yyunput( int c, register char *yy_bp )
1626 #else
1627 static void yyunput( c, yy_bp )
1628 int c;
1629 register char *yy_bp;
1630 #endif
1631         {
1632         register char *yy_cp = yy_c_buf_p;
1633
1634         /* undo effects of setting up yytext */
1635         *yy_cp = yy_hold_char;
1636
1637         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1638                 { /* need to shift things up to make room */
1639                 /* +2 for EOB chars. */
1640                 register int number_to_move = yy_n_chars + 2;
1641                 register char *dest = &yy_current_buffer->yy_ch_buf[
1642                                         yy_current_buffer->yy_buf_size + 2];
1643                 register char *source =
1644                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1645
1646                 while ( source > yy_current_buffer->yy_ch_buf )
1647                         *--dest = *--source;
1648
1649                 yy_cp += (int) (dest - source);
1650                 yy_bp += (int) (dest - source);
1651                 yy_current_buffer->yy_n_chars =
1652                         yy_n_chars = yy_current_buffer->yy_buf_size;
1653
1654                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1655                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1656                 }
1657
1658         *--yy_cp = (char) c;
1659
1660
1661         yytext_ptr = yy_bp;
1662         yy_hold_char = *yy_cp;
1663         yy_c_buf_p = yy_cp;
1664         }
1665 #endif  /* ifndef YY_NO_UNPUT */
1666
1667
1668 #ifndef YY_NO_INPUT
1669 #ifdef __cplusplus
1670 static int yyinput()
1671 #else
1672 static int input()
1673 #endif
1674         {
1675         int c;
1676
1677         *yy_c_buf_p = yy_hold_char;
1678
1679         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1680                 {
1681                 /* yy_c_buf_p now points to the character we want to return.
1682                  * If this occurs *before* the EOB characters, then it's a
1683                  * valid NUL; if not, then we've hit the end of the buffer.
1684                  */
1685                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1686                         /* This was really a NUL. */
1687                         *yy_c_buf_p = '\0';
1688
1689                 else
1690                         { /* need more input */
1691                         int offset = yy_c_buf_p - yytext_ptr;
1692                         ++yy_c_buf_p;
1693
1694                         switch ( yy_get_next_buffer() )
1695                                 {
1696                                 case EOB_ACT_LAST_MATCH:
1697                                         /* This happens because yy_g_n_b()
1698                                          * sees that we've accumulated a
1699                                          * token and flags that we need to
1700                                          * try matching the token before
1701                                          * proceeding.  But for input(),
1702                                          * there's no matching to consider.
1703                                          * So convert the EOB_ACT_LAST_MATCH
1704                                          * to EOB_ACT_END_OF_FILE.
1705                                          */
1706
1707                                         /* Reset buffer status. */
1708                                         yyrestart( yyin );
1709
1710                                         /* fall through */
1711
1712                                 case EOB_ACT_END_OF_FILE:
1713                                         {
1714                                         if ( yywrap() )
1715                                                 return EOF;
1716
1717                                         if ( ! yy_did_buffer_switch_on_eof )
1718                                                 YY_NEW_FILE;
1719 #ifdef __cplusplus
1720                                         return yyinput();
1721 #else
1722                                         return input();
1723 #endif
1724                                         }
1725
1726                                 case EOB_ACT_CONTINUE_SCAN:
1727                                         yy_c_buf_p = yytext_ptr + offset;
1728                                         break;
1729                                 }
1730                         }
1731                 }
1732
1733         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1734         *yy_c_buf_p = '\0';     /* preserve yytext */
1735         yy_hold_char = *++yy_c_buf_p;
1736
1737
1738         return c;
1739         }
1740 #endif /* YY_NO_INPUT */
1741
1742 #ifdef YY_USE_PROTOS
1743 void yyrestart( FILE *input_file )
1744 #else
1745 void yyrestart( input_file )
1746 FILE *input_file;
1747 #endif
1748         {
1749         if ( ! yy_current_buffer )
1750                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1751
1752         yy_init_buffer( yy_current_buffer, input_file );
1753         yy_load_buffer_state();
1754         }
1755
1756
1757 #ifdef YY_USE_PROTOS
1758 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1759 #else
1760 void yy_switch_to_buffer( new_buffer )
1761 YY_BUFFER_STATE new_buffer;
1762 #endif
1763         {
1764         if ( yy_current_buffer == new_buffer )
1765                 return;
1766
1767         if ( yy_current_buffer )
1768                 {
1769                 /* Flush out information for old buffer. */
1770                 *yy_c_buf_p = yy_hold_char;
1771                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1772                 yy_current_buffer->yy_n_chars = yy_n_chars;
1773                 }
1774
1775         yy_current_buffer = new_buffer;
1776         yy_load_buffer_state();
1777
1778         /* We don't actually know whether we did this switch during
1779          * EOF (yywrap()) processing, but the only time this flag
1780          * is looked at is after yywrap() is called, so it's safe
1781          * to go ahead and always set it.
1782          */
1783         yy_did_buffer_switch_on_eof = 1;
1784         }
1785
1786
1787 #ifdef YY_USE_PROTOS
1788 void yy_load_buffer_state( void )
1789 #else
1790 void yy_load_buffer_state()
1791 #endif
1792         {
1793         yy_n_chars = yy_current_buffer->yy_n_chars;
1794         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1795         yyin = yy_current_buffer->yy_input_file;
1796         yy_hold_char = *yy_c_buf_p;
1797         }
1798
1799
1800 #ifdef YY_USE_PROTOS
1801 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1802 #else
1803 YY_BUFFER_STATE yy_create_buffer( file, size )
1804 FILE *file;
1805 int size;
1806 #endif
1807         {
1808         YY_BUFFER_STATE b;
1809
1810         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1811         if ( ! b )
1812                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1813
1814         b->yy_buf_size = size;
1815
1816         /* yy_ch_buf has to be 2 characters longer than the size given because
1817          * we need to put in 2 end-of-buffer characters.
1818          */
1819         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1820         if ( ! b->yy_ch_buf )
1821                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1822
1823         b->yy_is_our_buffer = 1;
1824
1825         yy_init_buffer( b, file );
1826
1827         return b;
1828         }
1829
1830
1831 #ifdef YY_USE_PROTOS
1832 void yy_delete_buffer( YY_BUFFER_STATE b )
1833 #else
1834 void yy_delete_buffer( b )
1835 YY_BUFFER_STATE b;
1836 #endif
1837         {
1838         if ( ! b )
1839                 return;
1840
1841         if ( b == yy_current_buffer )
1842                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1843
1844         if ( b->yy_is_our_buffer )
1845                 yy_flex_free( (void *) b->yy_ch_buf );
1846
1847         yy_flex_free( (void *) b );
1848         }
1849
1850
1851
1852 #ifdef YY_USE_PROTOS
1853 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1854 #else
1855 void yy_init_buffer( b, file )
1856 YY_BUFFER_STATE b;
1857 FILE *file;
1858 #endif
1859
1860
1861         {
1862         yy_flush_buffer( b );
1863
1864         b->yy_input_file = file;
1865         b->yy_fill_buffer = 1;
1866
1867 #if YY_ALWAYS_INTERACTIVE
1868         b->yy_is_interactive = 1;
1869 #else
1870 #if YY_NEVER_INTERACTIVE
1871         b->yy_is_interactive = 0;
1872 #else
1873         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1874 #endif
1875 #endif
1876         }
1877
1878
1879 #ifdef YY_USE_PROTOS
1880 void yy_flush_buffer( YY_BUFFER_STATE b )
1881 #else
1882 void yy_flush_buffer( b )
1883 YY_BUFFER_STATE b;
1884 #endif
1885
1886         {
1887         if ( ! b )
1888                 return;
1889
1890         b->yy_n_chars = 0;
1891
1892         /* We always need two end-of-buffer characters.  The first causes
1893          * a transition to the end-of-buffer state.  The second causes
1894          * a jam in that state.
1895          */
1896         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1897         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1898
1899         b->yy_buf_pos = &b->yy_ch_buf[0];
1900
1901         b->yy_at_bol = 1;
1902         b->yy_buffer_status = YY_BUFFER_NEW;
1903
1904         if ( b == yy_current_buffer )
1905                 yy_load_buffer_state();
1906         }
1907
1908
1909 #ifndef YY_NO_SCAN_BUFFER
1910 #ifdef YY_USE_PROTOS
1911 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1912 #else
1913 YY_BUFFER_STATE yy_scan_buffer( base, size )
1914 char *base;
1915 yy_size_t size;
1916 #endif
1917         {
1918         YY_BUFFER_STATE b;
1919
1920         if ( size < 2 ||
1921              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1922              base[size-1] != YY_END_OF_BUFFER_CHAR )
1923                 /* They forgot to leave room for the EOB's. */
1924                 return 0;
1925
1926         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1927         if ( ! b )
1928                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1929
1930         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1931         b->yy_buf_pos = b->yy_ch_buf = base;
1932         b->yy_is_our_buffer = 0;
1933         b->yy_input_file = 0;
1934         b->yy_n_chars = b->yy_buf_size;
1935         b->yy_is_interactive = 0;
1936         b->yy_at_bol = 1;
1937         b->yy_fill_buffer = 0;
1938         b->yy_buffer_status = YY_BUFFER_NEW;
1939
1940         yy_switch_to_buffer( b );
1941
1942         return b;
1943         }
1944 #endif
1945
1946
1947 #ifndef YY_NO_SCAN_STRING
1948 #ifdef YY_USE_PROTOS
1949 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1950 #else
1951 YY_BUFFER_STATE yy_scan_string( yy_str )
1952 yyconst char *yy_str;
1953 #endif
1954         {
1955         int len;
1956         for ( len = 0; yy_str[len]; ++len )
1957                 ;
1958
1959         return yy_scan_bytes( yy_str, len );
1960         }
1961 #endif
1962
1963
1964 #ifndef YY_NO_SCAN_BYTES
1965 #ifdef YY_USE_PROTOS
1966 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1967 #else
1968 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1969 yyconst char *bytes;
1970 int len;
1971 #endif
1972         {
1973         YY_BUFFER_STATE b;
1974         char *buf;
1975         yy_size_t n;
1976         int i;
1977
1978         /* Get memory for full buffer, including space for trailing EOB's. */
1979         n = len + 2;
1980         buf = (char *) yy_flex_alloc( n );
1981         if ( ! buf )
1982                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1983
1984         for ( i = 0; i < len; ++i )
1985                 buf[i] = bytes[i];
1986
1987         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1988
1989         b = yy_scan_buffer( buf, n );
1990         if ( ! b )
1991                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1992
1993         /* It's okay to grow etc. this buffer, and we should throw it
1994          * away when we're done.
1995          */
1996         b->yy_is_our_buffer = 1;
1997
1998         return b;
1999         }
2000 #endif
2001
2002
2003 #ifndef YY_NO_PUSH_STATE
2004 #ifdef YY_USE_PROTOS
2005 static void yy_push_state( int new_state )
2006 #else
2007 static void yy_push_state( new_state )
2008 int new_state;
2009 #endif
2010         {
2011         if ( yy_start_stack_ptr >= yy_start_stack_depth )
2012                 {
2013                 yy_size_t new_size;
2014
2015                 yy_start_stack_depth += YY_START_STACK_INCR;
2016                 new_size = yy_start_stack_depth * sizeof( int );
2017
2018                 if ( ! yy_start_stack )
2019                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2020
2021                 else
2022                         yy_start_stack = (int *) yyxrealloc(
2023                                         (void *) yy_start_stack, new_size );
2024
2025                 if ( ! yy_start_stack )
2026                         YY_FATAL_ERROR(
2027                         "out of memory expanding start-condition stack" );
2028                 }
2029
2030         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2031
2032         BEGIN(new_state);
2033         }
2034 #endif
2035
2036
2037 #ifndef YY_NO_POP_STATE
2038 static void yy_pop_state()
2039         {
2040         if ( --yy_start_stack_ptr < 0 )
2041                 YY_FATAL_ERROR( "start-condition stack underflow" );
2042
2043         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2044         }
2045 #endif
2046
2047
2048 #ifndef YY_NO_TOP_STATE
2049 static int yy_top_state()
2050         {
2051         return yy_start_stack[yy_start_stack_ptr - 1];
2052         }
2053 #endif
2054
2055 #ifndef YY_EXIT_FAILURE
2056 #define YY_EXIT_FAILURE 2
2057 #endif
2058
2059 #ifdef YY_USE_PROTOS
2060 static void yy_fatal_error( yyconst char msg[] )
2061 #else
2062 static void yy_fatal_error( msg )
2063 char msg[];
2064 #endif
2065         {
2066         (void) fprintf( stderr, "%s\n", msg );
2067         exit( YY_EXIT_FAILURE );
2068         }
2069
2070
2071
2072 /* Redefine yyless() so it works in section 3 code. */
2073
2074 #undef yyless
2075 #define yyless(n) \
2076         do \
2077                 { \
2078                 /* Undo effects of setting up yytext. */ \
2079                 yytext[yyleng] = yy_hold_char; \
2080                 yy_c_buf_p = yytext + n; \
2081                 yy_hold_char = *yy_c_buf_p; \
2082                 *yy_c_buf_p = '\0'; \
2083                 yyleng = n; \
2084                 } \
2085         while ( 0 )
2086
2087
2088 /* Internal utility routines. */
2089
2090 #ifndef yytext_ptr
2091 #ifdef YY_USE_PROTOS
2092 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2093 #else
2094 static void yy_flex_strncpy( s1, s2, n )
2095 char *s1;
2096 yyconst char *s2;
2097 int n;
2098 #endif
2099         {
2100         register int i;
2101         for ( i = 0; i < n; ++i )
2102                 s1[i] = s2[i];
2103         }
2104 #endif
2105
2106 #ifdef YY_NEED_STRLEN
2107 #ifdef YY_USE_PROTOS
2108 static int yy_flex_strlen( yyconst char *s )
2109 #else
2110 static int yy_flex_strlen( s )
2111 yyconst char *s;
2112 #endif
2113         {
2114         register int n;
2115         for ( n = 0; s[n]; ++n )
2116                 ;
2117
2118         return n;
2119         }
2120 #endif
2121
2122
2123 #ifdef YY_USE_PROTOS
2124 static void *yy_flex_alloc( yy_size_t size )
2125 #else
2126 static void *yy_flex_alloc( size )
2127 yy_size_t size;
2128 #endif
2129         {
2130         return (void *) xmalloc( size );
2131         }
2132
2133 #ifdef YY_USE_PROTOS
2134 static void *yyxrealloc( void *ptr, yy_size_t size )
2135 #else
2136 static void *yyxrealloc( ptr, size )
2137 void *ptr;
2138 yy_size_t size;
2139 #endif
2140         {
2141         /* The cast to (char *) in the following accommodates both
2142          * implementations that use char* generic pointers, and those
2143          * that use void* generic pointers.  It works with the latter
2144          * because both ANSI C and C++ allow castless assignment from
2145          * any pointer type to void*, and deal with argument conversions
2146          * as though doing an assignment.
2147          */
2148         return (void *) xrealloc( (char *) ptr, size );
2149         }
2150
2151 #ifdef YY_USE_PROTOS
2152 static void yy_flex_free( void *ptr )
2153 #else
2154 static void yy_flex_free( ptr )
2155 void *ptr;
2156 #endif
2157         {
2158         xfree( ptr );
2159         }
2160
2161 #if YY_MAIN
2162 int main()
2163         {
2164         yylex();
2165         return 0;
2166         }
2167 #endif
2168 #line 289 "ada-lex.l"
2169
2170
2171 #include <ctype.h>
2172 #include "gdb_string.h"
2173
2174 /* Initialize the lexer for processing new expression. */
2175
2176 void
2177 lexer_init (FILE *inp)
2178 {
2179   BEGIN INITIAL;
2180   yyrestart (inp);
2181 }
2182
2183
2184 /* Copy S2 to S1, removing all underscores, and downcasing all letters.  */
2185
2186 static void
2187 canonicalizeNumeral (char *s1, const char *s2)
2188 {
2189   for (; *s2 != '\000'; s2 += 1)
2190     {
2191       if (*s2 != '_')
2192         {
2193           *s1 = tolower(*s2);
2194           s1 += 1;
2195         }
2196     }
2197   s1[0] = '\000';
2198 }
2199
2200 /* Interprets the prefix of NUM that consists of digits of the given BASE
2201    as an integer of that BASE, with the string EXP as an exponent.
2202    Puts value in yylval, and returns INT, if the string is valid.  Causes
2203    an error if the number is improperly formated.   BASE, if NULL, defaults
2204    to "10", and EXP to "1".  The EXP does not contain a leading 'e' or 'E'.
2205  */
2206
2207 static int
2208 processInt (const char *base0, const char *num0, const char *exp0)
2209 {
2210   ULONGEST result;
2211   long exp;
2212   int base;
2213
2214   char *trailer;
2215
2216   if (base0 == NULL)
2217     base = 10;
2218   else
2219     {
2220       base = strtol (base0, (char **) NULL, 10);
2221       if (base < 2 || base > 16)
2222         error (_("Invalid base: %d."), base);
2223     }
2224
2225   if (exp0 == NULL)
2226     exp = 0;
2227   else
2228     exp = strtol(exp0, (char **) NULL, 10);
2229
2230   errno = 0;
2231   result = strtoulst (num0, (const char **) &trailer, base);
2232   if (errno == ERANGE)
2233     error (_("Integer literal out of range"));
2234   if (isxdigit(*trailer))
2235     error (_("Invalid digit `%c' in based literal"), *trailer);
2236
2237   while (exp > 0)
2238     {
2239       if (result > (ULONG_MAX / base))
2240         error (_("Integer literal out of range"));
2241       result *= base;
2242       exp -= 1;
2243     }
2244
2245   if ((result >> (gdbarch_int_bit (parse_gdbarch)-1)) == 0)
2246     yylval.typed_val.type = type_int ();
2247   else if ((result >> (gdbarch_long_bit (parse_gdbarch)-1)) == 0)
2248     yylval.typed_val.type = type_long ();
2249   else if (((result >> (gdbarch_long_bit (parse_gdbarch)-1)) >> 1) == 0)
2250     {
2251       /* We have a number representable as an unsigned integer quantity.
2252          For consistency with the C treatment, we will treat it as an
2253          anonymous modular (unsigned) quantity.  Alas, the types are such
2254          that we need to store .val as a signed quantity.  Sorry
2255          for the mess, but C doesn't officially guarantee that a simple
2256          assignment does the trick (no, it doesn't; read the reference manual).
2257        */
2258       yylval.typed_val.type
2259         = builtin_type (parse_gdbarch)->builtin_unsigned_long;
2260       if (result & LONGEST_SIGN)
2261         yylval.typed_val.val =
2262           (LONGEST) (result & ~LONGEST_SIGN)
2263           - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
2264       else
2265         yylval.typed_val.val = (LONGEST) result;
2266       return INT;
2267     }
2268   else
2269     yylval.typed_val.type = type_long_long ();
2270
2271   yylval.typed_val.val = (LONGEST) result;
2272   return INT;
2273 }
2274
2275 static int
2276 processReal (const char *num0)
2277 {
2278   sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval);
2279
2280   yylval.typed_val_float.type = type_float ();
2281   if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch)
2282                             / TARGET_CHAR_BIT)
2283     yylval.typed_val_float.type = type_double ();
2284   if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch)
2285                             / TARGET_CHAR_BIT)
2286     yylval.typed_val_float.type = type_long_double ();
2287
2288   return FLOAT;
2289 }
2290
2291
2292 /* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym.  The
2293    resulting string is valid until the next call to ada_parse.  It differs
2294    from NAME0 in that:
2295     + Characters between '...' or <...> are transfered verbatim to
2296       yylval.ssym.
2297     + <, >, and trailing "'" characters in quoted sequences are removed
2298       (a leading quote is preserved to indicate that the name is not to be
2299       GNAT-encoded).
2300     + Unquoted whitespace is removed.
2301     + Unquoted alphabetic characters are mapped to lower case.
2302    Result is returned as a struct stoken, but for convenience, the string
2303    is also null-terminated.  Result string valid until the next call of
2304    ada_parse.
2305  */
2306 static struct stoken
2307 processId (const char *name0, int len)
2308 {
2309   char *name = obstack_alloc (&temp_parse_space, len + 11);
2310   int i0, i;
2311   struct stoken result;
2312
2313   while (len > 0 && isspace (name0[len-1]))
2314     len -= 1;
2315   i = i0 = 0;
2316   while (i0 < len)
2317     {
2318       if (isalnum (name0[i0]))
2319         {
2320           name[i] = tolower (name0[i0]);
2321           i += 1; i0 += 1;
2322         }
2323       else switch (name0[i0])
2324         {
2325         default:
2326           name[i] = name0[i0];
2327           i += 1; i0 += 1;
2328           break;
2329         case ' ': case '\t':
2330           i0 += 1;
2331           break;
2332         case '\'':
2333           do
2334             {
2335               name[i] = name0[i0];
2336               i += 1; i0 += 1;
2337             }
2338           while (i0 < len && name0[i0] != '\'');
2339           i0 += 1;
2340           break;
2341         case '<':
2342           i0 += 1;
2343           while (i0 < len && name0[i0] != '>')
2344             {
2345               name[i] = name0[i0];
2346               i += 1; i0 += 1;
2347             }
2348           i0 += 1;
2349           break;
2350         }
2351     }
2352   name[i] = '\000';
2353
2354   result.ptr = name;
2355   result.length = i;
2356   return result;
2357 }
2358
2359 /* Return TEXT[0..LEN-1], a string literal without surrounding quotes,
2360    with special hex character notations replaced with characters.
2361    Result valid until the next call to ada_parse.  */
2362
2363 static struct stoken
2364 processString (const char *text, int len)
2365 {
2366   const char *p;
2367   char *q;
2368   const char *lim = text + len;
2369   struct stoken result;
2370
2371   q = result.ptr = obstack_alloc (&temp_parse_space, len);
2372   p = text;
2373   while (p < lim)
2374     {
2375       if (p[0] == '[' && p[1] == '"' && p+2 < lim)
2376          {
2377            if (p[2] == '"')  /* "...["""]... */
2378              {
2379                *q = '"';
2380                p += 4;
2381              }
2382            else
2383              {
2384                int chr;
2385                sscanf (p+2, "%2x", &chr);
2386                *q = (char) chr;
2387                p += 5;
2388              }
2389          }
2390        else
2391          *q = *p;
2392        q += 1;
2393        p += 1;
2394      }
2395   result.length = q - result.ptr;
2396   return result;
2397 }
2398
2399 /* Returns the position within STR of the '.' in a
2400    '.{WHITE}*all' component of a dotted name, or -1 if there is none.
2401    Note: we actually don't need this routine, since 'all' can never be an
2402    Ada identifier.  Thus, looking up foo.all or foo.all.x as a name
2403    must fail, and will eventually be interpreted as (foo).all or
2404    (foo).all.x.  However, this does avoid an extraneous lookup. */
2405
2406 static int
2407 find_dot_all (const char *str)
2408 {
2409   int i;
2410   for (i = 0; str[i] != '\000'; i += 1)
2411     {
2412       if (str[i] == '.')
2413         {
2414           int i0 = i;
2415           do
2416             i += 1;
2417           while (isspace (str[i]));
2418           if (strncmp (str+i, "all", 3) == 0
2419               && ! isalnum (str[i+3]) && str[i+3] != '_')
2420             return i0;
2421         }
2422     }
2423   return -1;
2424 }
2425
2426 /* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
2427    case.  */
2428
2429 static int
2430 subseqMatch (const char *subseq, const char *str)
2431 {
2432   if (subseq[0] == '\0')
2433     return 1;
2434   else if (str[0] == '\0')
2435     return 0;
2436   else if (tolower (subseq[0]) == tolower (str[0]))
2437     return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
2438   else
2439     return subseqMatch (subseq, str+1);
2440 }
2441
2442
2443 static struct { const char *name; int code; }
2444 attributes[] = {
2445   { "address", TICK_ADDRESS },
2446   { "unchecked_access", TICK_ACCESS },
2447   { "unrestricted_access", TICK_ACCESS },
2448   { "access", TICK_ACCESS },
2449   { "first", TICK_FIRST },
2450   { "last", TICK_LAST },
2451   { "length", TICK_LENGTH },
2452   { "max", TICK_MAX },
2453   { "min", TICK_MIN },
2454   { "modulus", TICK_MODULUS },
2455   { "pos", TICK_POS },
2456   { "range", TICK_RANGE },
2457   { "size", TICK_SIZE },
2458   { "tag", TICK_TAG },
2459   { "val", TICK_VAL },
2460   { NULL, -1 }
2461 };
2462
2463 /* Return the syntactic code corresponding to the attribute name or
2464    abbreviation STR.  */
2465
2466 static int
2467 processAttribute (const char *str)
2468 {
2469   int i, k;
2470
2471   for (i = 0; attributes[i].code != -1; i += 1)
2472     if (strcasecmp (str, attributes[i].name) == 0)
2473       return attributes[i].code;
2474
2475   for (i = 0, k = -1; attributes[i].code != -1; i += 1)
2476     if (subseqMatch (str, attributes[i].name))
2477       {
2478         if (k == -1)
2479           k = i;
2480         else
2481           error (_("ambiguous attribute name: `%s'"), str);
2482       }
2483   if (k == -1)
2484     error (_("unrecognized attribute: `%s'"), str);
2485
2486   return attributes[k].code;
2487 }
2488
2489 int
2490 yywrap(void)
2491 {
2492   return 1;
2493 }
2494
2495 /* Dummy definition to suppress warnings about unused static definitions. */
2496 typedef void (*dummy_function) ();
2497 dummy_function ada_flex_use[] =
2498 {
2499   (dummy_function) yyunput
2500 };