GDB (xrefs)
Classes | Defines | Typedefs | Functions | Variables
/home/stan/gdb/linux/gdb/ada-lex.c File Reference
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include "gdb_string.h"

Go to the source code of this file.

Classes

struct  yy_trans_info

Defines

#define YY_INT_ALIGNED   short int
#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION   2
#define YY_FLEX_MINOR_VERSION   5
#define YY_FLEX_SUBMINOR_VERSION   35
#define FLEX_BETA
#define yyconst
#define YY_NULL   0
#define YY_SC_TO_UI(c)   ((unsigned int) (unsigned char) c)
#define BEGIN   (yy_start) = 1 + 2 *
#define YY_START   (((yy_start) - 1) / 2)
#define YYSTATE   YY_START
#define YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
#define YY_NEW_FILE   yyrestart(yyin )
#define YY_END_OF_BUFFER_CHAR   0
#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
#define EOB_ACT_CONTINUE_SCAN   0
#define EOB_ACT_END_OF_FILE   1
#define EOB_ACT_LAST_MATCH   2
#define YY_LESS_LINENO(n)
#define yyless(n)
#define unput(c)   yyunput( c, (yytext_ptr) )
#define YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]
#define YY_FLUSH_BUFFER   yy_flush_buffer(YY_CURRENT_BUFFER )
#define yy_new_buffer   yy_create_buffer
#define yy_set_interactive(is_interactive)
#define yy_set_bol(at_bol)
#define YY_AT_BOL()   (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
#define yytext_ptr   yytext
#define YY_DO_BEFORE_ACTION
#define YY_NUM_RULES   55
#define YY_END_OF_BUFFER   56
#define REJECT   reject_used_but_not_detected
#define yymore()   yymore_used_but_not_detected
#define YY_MORE_ADJ   0
#define YY_RESTORE_YY_MORE_OFFSET
#define NUMERAL_WIDTH   256
#define LONGEST_SIGN   ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
#define YY_DECL   static int yylex ( void )
#define YY_NO_INPUT
#define YY_INPUT(BUF, RESULT, MAX_SIZE)
#define INITIAL   0
#define BEFORE_QUAL_QUOTE   1
#define YY_RULE_SETUP   YY_USER_ACTION
#define yyless(n)
#define YYTABLES_NAME   "yytables"

Typedefs

typedef unsigned char YY_CHAR
typedef int yy_state_type
typedef void(* dummy_function )()

Functions

void yyrestart (FILE *input_file)
void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer)
YY_BUFFER_STATE yy_create_buffer (FILE *file, int size)
void yy_delete_buffer (YY_BUFFER_STATE b)
void yy_flush_buffer (YY_BUFFER_STATE b)
void yypush_buffer_state (YY_BUFFER_STATE new_buffer)
void yypop_buffer_state (void)
static void yyensure_buffer_stack (void)
static void yy_load_buffer_state (void)
static void yy_init_buffer (YY_BUFFER_STATE b, FILE *file)
YY_BUFFER_STATE yy_scan_buffer (char *base, yy_size_t size)
YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str)
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes, int len)
void * yyalloc (yy_size_t)
void * yyxrealloc (void *, yy_size_t)
void yyfree (void *)
static yy_state_type yy_get_previous_state (void)
static yy_state_type yy_try_NUL_trans (yy_state_type current_state)
static int yy_get_next_buffer (void)
static void yy_fatal_error (yyconst char msg[])
static void canonicalizeNumeral (char *s1, const char *)
static struct stoken processString (const char *, int)
static int processInt (const char *, const char *, const char *)
static int processReal (const char *)
static struct stoken processId (const char *, int)
static int processAttribute (const char *)
static int find_dot_all (const char *)
static void rewind_to_char (int)
static int yy_init_globals (void)
int yylex_destroy (void)
int yyget_debug (void)
void yyset_debug (int debug_flag)
YY_EXTRA_TYPE yyget_extra (void)
void yyset_extra (YY_EXTRA_TYPE user_defined)
FILE * yyget_in (void)
void yyset_in (FILE *in_str)
FILE * yyget_out (void)
void yyset_out (FILE *out_str)
int yyget_leng (void)
char * yyget_text (void)
int yyget_lineno (void)
void yyset_lineno (int line_number)
int yywrap (void)
static void yyunput (int c, char *buf_ptr)
static void yy_fatal_error (yyconst char *msg)
static void lexer_init (FILE *inp)
static int subseqMatch (const char *subseq, const char *str)

Variables

int yyleng
FILE * yyin = (FILE *) 0
FILE * yyout = (FILE *) 0
static size_t yy_buffer_stack_top = 0
static size_t yy_buffer_stack_max = 0
static YY_BUFFER_STATE * yy_buffer_stack = 0
static char yy_hold_char
static int yy_n_chars
static char * yy_c_buf_p = (char *) 0
static int yy_init = 0
static int yy_start = 0
static int yy_did_buffer_switch_on_eof
int yylineno = 1
char * yytext
static yyconst flex_int16_t yy_accept [207]
static yyconst flex_int32_t yy_ec [256]
static yyconst flex_int32_t yy_meta [68]
static yyconst flex_int16_t yy_base [229]
static yyconst flex_int16_t yy_def [229]
static yyconst flex_int16_t yy_nxt [1320]
static yyconst flex_int16_t yy_chk [1320]
static yy_state_type yy_last_accepting_state
static char * yy_last_accepting_cpos
int yy_flex_debug = 0
static char numbuf [NUMERAL_WIDTH]
struct {
   const char *   name
   int   code
} attributes []
dummy_function ada_flex_use []

Define Documentation

#define BEFORE_QUAL_QUOTE   1

Definition at line 885 of file ada-lex.c.

#define BEGIN   (yy_start) = 1 + 2 *

Definition at line 126 of file ada-lex.c.

Referenced by lexer_init().

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 169 of file ada-lex.c.

#define EOB_ACT_END_OF_FILE   1

Definition at line 170 of file ada-lex.c.

#define EOB_ACT_LAST_MATCH   2

Definition at line 171 of file ada-lex.c.

#define FLEX_BETA

Definition at line 14 of file ada-lex.c.

#define FLEX_SCANNER

Definition at line 9 of file ada-lex.c.

#define INITIAL   0

Definition at line 884 of file ada-lex.c.

Referenced by lexer_init().

#define LONGEST_SIGN   ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))

Definition at line 848 of file ada-lex.c.

Referenced by processInt().

#define NUMERAL_WIDTH   256

Definition at line 847 of file ada-lex.c.

#define REJECT   reject_used_but_not_detected

Definition at line 816 of file ada-lex.c.

#define unput (   c)    yyunput( c, (yytext_ptr) )

Definition at line 189 of file ada-lex.c.

#define YY_AT_BOL ( )    (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 340 of file ada-lex.c.

#define YY_CURRENT_BUFFER
Value:
( (yy_buffer_stack) \
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                          : NULL)

Definition at line 272 of file ada-lex.c.

Referenced by yy_flush_buffer(), yy_init_buffer(), yylex_destroy(), yypop_buffer_state(), and yypush_buffer_state().

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 279 of file ada-lex.c.

Referenced by yylex_destroy(), yypop_buffer_state(), and yypush_buffer_state().

#define YY_DECL   static int yylex ( void )

Definition at line 862 of file ada-lex.c.

#define YY_DO_BEFORE_ACTION
Value:
(yytext_ptr) = yy_bp; \
        yyleng = (size_t) (yy_cp - yy_bp); \
        (yy_hold_char) = *yy_cp; \
        *yy_cp = '\0'; \
        (yy_c_buf_p) = yy_cp;

Definition at line 365 of file ada-lex.c.

#define YY_END_OF_BUFFER   56

Definition at line 373 of file ada-lex.c.

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 141 of file ada-lex.c.

Referenced by yy_flush_buffer(), yy_scan_buffer(), and yy_scan_bytes().

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 10 of file ada-lex.c.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 11 of file ada-lex.c.

#define YY_FLEX_SUBMINOR_VERSION   35

Definition at line 12 of file ada-lex.c.

#define YY_FLUSH_BUFFER   yy_flush_buffer(YY_CURRENT_BUFFER )

Definition at line 308 of file ada-lex.c.

#define YY_INPUT (   BUF,
  RESULT,
  MAX_SIZE 
)
Value:
if ( *lexptr == '\000' ) \
      (RESULT) = YY_NULL; \
    else \
      { \
        *(BUF) = *lexptr; \
        (RESULT) = 1; \
        lexptr += 1; \
      }

Definition at line 869 of file ada-lex.c.

#define YY_INT_ALIGNED   short int

Definition at line 5 of file ada-lex.c.

#define YY_LESS_LINENO (   n)

Definition at line 173 of file ada-lex.c.

#define YY_MORE_ADJ   0

Definition at line 818 of file ada-lex.c.

#define yy_new_buffer   yy_create_buffer

Definition at line 318 of file ada-lex.c.

#define YY_NEW_FILE   yyrestart(yyin )

Definition at line 139 of file ada-lex.c.

#define YY_NO_INPUT

Definition at line 866 of file ada-lex.c.

#define YY_NULL   0

Definition at line 113 of file ada-lex.c.

#define YY_NUM_RULES   55

Definition at line 372 of file ada-lex.c.

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 819 of file ada-lex.c.

#define YY_RULE_SETUP   YY_USER_ACTION

Definition at line 1059 of file ada-lex.c.

#define YY_SC_TO_UI (   c)    ((unsigned int) (unsigned char) c)

Definition at line 120 of file ada-lex.c.

#define yy_set_bol (   at_bol)
Value:
{ \
        if ( ! YY_CURRENT_BUFFER ){\
        yyensure_buffer_stack (); \
                YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
        } \
        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
        }

Definition at line 330 of file ada-lex.c.

#define yy_set_interactive (   is_interactive)
Value:
{ \
        if ( ! YY_CURRENT_BUFFER ){ \
        yyensure_buffer_stack (); \
                YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
        } \
        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
        }

Definition at line 320 of file ada-lex.c.

#define YY_START   (((yy_start) - 1) / 2)

Definition at line 132 of file ada-lex.c.

#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

Definition at line 158 of file ada-lex.c.

#define YY_STATE_EOF (   state)    (YY_END_OF_BUFFER + state + 1)

Definition at line 136 of file ada-lex.c.

#define yyconst

Definition at line 109 of file ada-lex.c.

#define yyless (   n)
Value:
do \
                { \
                /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
                *yy_cp = (yy_hold_char); \
                YY_RESTORE_YY_MORE_OFFSET \
                (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
                } \
        while ( 0 )

Definition at line 2349 of file ada-lex.c.

#define yyless (   n)
Value:
do \
                { \
                /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
                yytext[yyleng] = (yy_hold_char); \
                (yy_c_buf_p) = yytext + yyless_macro_arg; \
                (yy_hold_char) = *(yy_c_buf_p); \
                *(yy_c_buf_p) = '\0'; \
                yyleng = yyless_macro_arg; \
                } \
        while ( 0 )

Definition at line 2349 of file ada-lex.c.

#define yymore ( )    yymore_used_but_not_detected

Definition at line 817 of file ada-lex.c.

#define YYSTATE   YY_START

Definition at line 133 of file ada-lex.c.

#define YYTABLES_NAME   "yytables"

Definition at line 2539 of file ada-lex.c.

#define yytext_ptr   yytext

Definition at line 355 of file ada-lex.c.

Typedef Documentation

typedef void(* dummy_function)()

Definition at line 2898 of file ada-lex.c.

typedef unsigned char YY_CHAR

Definition at line 344 of file ada-lex.c.

typedef int yy_state_type

Definition at line 348 of file ada-lex.c.

Function Documentation

static void canonicalizeNumeral ( char *  s1,
const char *  s2 
) [static]

Definition at line 2561 of file ada-lex.c.

static int find_dot_all ( const char *  str) [static]

Definition at line 2792 of file ada-lex.c.

static void lexer_init ( FILE *  inp) [static]

Definition at line 2551 of file ada-lex.c.

References BEGIN, INITIAL, and yyrestart().

Referenced by ada_parse().

static int processAttribute ( const char *  str) [static]

Definition at line 2852 of file ada-lex.c.

References _, attributes, error(), name, and subseqMatch().

static struct stoken processId ( const char *  name0,
int  len 
) [static, read]

Definition at line 2682 of file ada-lex.c.

References len, stoken::length, name, stoken::ptr, strstr(), and temp_parse_space.

static int processInt ( const char *  base0,
const char *  num0,
const char *  exp0 
) [static]

Definition at line 2582 of file ada-lex.c.

References _, builtin_type(), builtin_type::builtin_unsigned_long, error(), gdbarch_int_bit(), gdbarch_long_bit(), INT, LONGEST, LONGEST_SIGN, parse_gdbarch, strtoulst(), type_int(), type_long(), type_long_long(), ULONGEST, and yylval.

static int processReal ( const char *  num0) [static]

Definition at line 2649 of file ada-lex.c.

References DOUBLEST_SCAN_FORMAT, FLOAT, gdbarch_double_bit(), gdbarch_long_double_bit(), parse_gdbarch, type_double(), type_float(), type_long_double(), and yylval.

static struct stoken processString ( const char *  text,
int  len 
) [static, read]

Definition at line 2748 of file ada-lex.c.

References len, stoken::length, p, stoken::ptr, and temp_parse_space.

static void rewind_to_char ( int  ch) [static]

Definition at line 2883 of file ada-lex.c.

References lexptr, yyleng, and yyrestart().

static int subseqMatch ( const char *  subseq,
const char *  str 
) [static]

Definition at line 2815 of file ada-lex.c.

Referenced by processAttribute().

YY_BUFFER_STATE yy_create_buffer ( FILE *  file,
int  size 
)
void yy_delete_buffer ( YY_BUFFER_STATE  b)

Referenced by yylex_destroy(), and yypop_buffer_state().

static void yy_fatal_error ( yyconst char  msg[]) [static]
static void yy_fatal_error ( yyconst char *  msg) [static]

Definition at line 2340 of file ada-lex.c.

void yy_flush_buffer ( YY_BUFFER_STATE  b)

Discard all buffered characters. On the next scan, YY_INPUT will be called.

Parameters:
bthe buffer state to be flushed, usually YY_CURRENT_BUFFER.

Definition at line 2129 of file ada-lex.c.

References YY_CURRENT_BUFFER, YY_END_OF_BUFFER_CHAR, and yy_load_buffer_state().

Referenced by yy_init_buffer().

static int yy_get_next_buffer ( void  ) [static]
static yy_state_type yy_get_previous_state ( void  ) [static]
static void yy_init_buffer ( YY_BUFFER_STATE  b,
FILE *  file 
) [static]

The main scanner function which does all the work.

Definition at line 2101 of file ada-lex.c.

References YY_CURRENT_BUFFER, and yy_flush_buffer().

static int yy_init_globals ( void  ) [static]

Definition at line 2443 of file ada-lex.c.

References yy_buffer_stack, yy_buffer_stack_max, yy_buffer_stack_top, yy_c_buf_p, yy_init, yy_start, yyin, and yyout.

Referenced by yylex_destroy().

static void yy_load_buffer_state ( void  ) [static]

Referenced by yy_flush_buffer(), yypop_buffer_state(), and yypush_buffer_state().

YY_BUFFER_STATE yy_scan_buffer ( char *  base,
yy_size_t  size 
)

Setup the input buffer state to scan directly from a user-specified character buffer.

Parameters:
basethe character buffer
sizethe size in bytes of the character buffer
Returns:
the newly allocated buffer state object.

Definition at line 2256 of file ada-lex.c.

References YY_END_OF_BUFFER_CHAR, yy_switch_to_buffer(), and yyalloc().

Referenced by yy_scan_bytes().

YY_BUFFER_STATE yy_scan_bytes ( yyconst char *  yybytes,
int  _yybytes_len 
)

Setup the input buffer state to scan the given bytes. The next call to yylex() will scan from a copy of bytes.

Parameters:
yybytesthe byte buffer to scan
_yybytes_lenthe number of bytes in the buffer pointed to by bytes.
Returns:
the newly allocated buffer state object.

Definition at line 2306 of file ada-lex.c.

References YY_END_OF_BUFFER_CHAR, yy_scan_buffer(), and yyalloc().

Referenced by yy_scan_string().

YY_BUFFER_STATE yy_scan_string ( yyconst char *  yystr)

Setup the input buffer state to scan a string. The next call to yylex() will scan from a copy of str.

Parameters:
yystra NUL-terminated string to scan
Returns:
the newly allocated buffer state object.
Note:
If you want to scan bytes that may contain NUL values, then use yy_scan_bytes() instead.

Definition at line 2293 of file ada-lex.c.

References yy_scan_bytes().

void yy_switch_to_buffer ( YY_BUFFER_STATE  new_buffer)

Referenced by yy_scan_buffer().

static yy_state_type yy_try_NUL_trans ( yy_state_type  current_state) [static]
void * yyalloc ( yy_size_t  size)

Definition at line 2517 of file ada-lex.c.

References xmalloc().

Referenced by yy_scan_buffer(), yy_scan_bytes(), and yyensure_buffer_stack().

static void yyensure_buffer_stack ( void  ) [static]

Definition at line 2207 of file ada-lex.c.

References memset(), yy_buffer_stack, yy_buffer_stack_max, yy_buffer_stack_top, yyalloc(), and yyxrealloc().

Referenced by yypush_buffer_state().

void yyfree ( void *  ptr)

Definition at line 2534 of file ada-lex.c.

References xfree().

Referenced by yylex_destroy().

int yyget_debug ( void  )

Definition at line 2433 of file ada-lex.c.

References yy_flex_debug.

YY_EXTRA_TYPE yyget_extra ( void  )
FILE * yyget_in ( void  )

Get the input stream.

Definition at line 2377 of file ada-lex.c.

References yyin.

int yyget_leng ( void  )

Get the length of the current token.

Definition at line 2393 of file ada-lex.c.

References yyleng.

int yyget_lineno ( void  )

Get the current line number.

Definition at line 2368 of file ada-lex.c.

References yylineno.

FILE * yyget_out ( void  )

Get the output stream.

Definition at line 2385 of file ada-lex.c.

References yyout.

char * yyget_text ( void  )

Get the current token.

Definition at line 2402 of file ada-lex.c.

References yytext.

int yylex_destroy ( void  )

Definition at line 2472 of file ada-lex.c.

References yy_buffer_stack, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_delete_buffer(), yy_init_globals(), yyfree(), and yypop_buffer_state().

void yypop_buffer_state ( void  )

Removes and deletes the top of the stack, if present. The next element becomes the new top.

Definition at line 2188 of file ada-lex.c.

References yy_buffer_stack_top, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_delete_buffer(), yy_did_buffer_switch_on_eof, and yy_load_buffer_state().

Referenced by yylex_destroy().

void yypush_buffer_state ( YY_BUFFER_STATE  new_buffer)

Pushes the new state onto the stack. The new state becomes the current state. This function will allocate the stack if necessary.

Parameters:
new_bufferThe new state.

Definition at line 2158 of file ada-lex.c.

References yy_buffer_stack_top, yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, yy_hold_char, yy_load_buffer_state(), yy_n_chars, and yyensure_buffer_stack().

void yyrestart ( FILE *  input_file)

Referenced by lexer_init(), and rewind_to_char().

void yyset_debug ( int  debug_flag)

Definition at line 2438 of file ada-lex.c.

void yyset_extra ( YY_EXTRA_TYPE  user_defined)
void yyset_in ( FILE *  in_str)

Set the input stream. This does not discard the current input buffer.

Parameters:
in_strA readable stream.
See also:
yy_switch_to_buffer

Definition at line 2423 of file ada-lex.c.

References yyin.

void yyset_lineno ( int  line_number)

Set the current line number.

Parameters:
line_number

Definition at line 2411 of file ada-lex.c.

void yyset_out ( FILE *  out_str)

Definition at line 2428 of file ada-lex.c.

References yyout.

static void yyunput ( int  c,
char *  buf_ptr 
) [static]
int yywrap ( void  )

Definition at line 2892 of file ada-lex.c.

void * yyxrealloc ( void *  ptr,
yy_size_t  size 
)

Definition at line 2522 of file ada-lex.c.

References xrealloc().

Referenced by yyensure_buffer_stack().

Variable Documentation

dummy_function ada_flex_use[]
Initial value:
 
{ 
  (dummy_function) yyunput
}

Definition at line 2899 of file ada-lex.c.

struct { ... } attributes[] [static]

Referenced by processAttribute(), and varobj_get_attributes().

int code

Definition at line 2828 of file ada-lex.c.

const char* name

Definition at line 2828 of file ada-lex.c.

char numbuf[NUMERAL_WIDTH] [static]

Definition at line 851 of file ada-lex.c.

yyconst flex_int16_t yy_accept[207] [static]
Initial value:
    {   0,
        0,    0,    0,    0,   56,   54,    1,    1,   15,   53,
       43,   54,   45,   46,   43,   44,   43,   43,   43,    4,
        4,   43,   43,   43,   43,   52,   49,   49,   49,   49,
       49,   49,   49,   49,   49,   49,   49,   42,    0,   14,
        0,   53,    0,    0,    0,    0,    0,    0,    0,   37,
        2,    0,   36,    0,   48,   48,   39,    0,    0,    4,
        0,    0,   51,   38,   40,    0,   35,   41,    0,    0,
       49,    0,   49,   49,   49,   49,   49,   16,   22,   49,
       49,   49,   49,   27,   49,   49,   49,   49,   49,   49,
        0,   14,    0,   12,   12,   34,    0,    2,    0,   48,

       48,    0,    9,    0,    3,    7,    0,   49,    0,    0,
        0,   49,   19,   20,   49,   49,   23,   24,   25,   49,
       49,   29,   49,   49,   49,   49,   31,    0,    0,    0,
        0,    0,    0,   48,   47,    6,    0,    0,    9,    0,
        3,    0,    0,    0,    0,    0,    0,    0,    0,    0,
        0,    0,    0,   49,   21,   49,   26,   49,   17,   30,
       49,   32,    0,   50,    0,    0,    0,    0,   49,    0,
        0,    0,    0,    0,    0,    0,    0,   33,   49,   49,
        0,    0,    5,   11,    0,    8,    0,    0,    0,    0,
        0,    0,   28,   49,    0,    5,    0,    8,    0,    0,

       13,    0,   18,   10,   10,    0
    }

Definition at line 381 of file ada-lex.c.

yyconst flex_int16_t yy_base[229] [static]
Initial value:
    {   0,
        0,    0,  649,  638,  646, 1252, 1252, 1252,   62,    0,
     1252,  109, 1252, 1252,  623, 1252,  619,  175,  606,  174,
      180,   48,  604,  592,  590, 1252,  204,   71,  214,  186,
      235,  244,  304,  256,   39,  368,   40,  430,  179, 1252,
      195,    0,  602,  595,  592,  585,  574,  497,   72, 1252,
        0,  273, 1252,    0,   39,    0, 1252,    0,   66,  262,
       75,    0, 1252, 1252, 1252,  557, 1252, 1252,  284,  300,
     1252,  322,  329,  349,  358,  377,  339,  396,  412,  563,
      566,  575,  584,  587,  569,  596,  623,  616,  576,  617,
      571,  568,  334,  380, 1252,  562,  677,    0,  403,    0,

       40,   89,  642,   71,  163,    0,  401,  672,  401,  723,
        0,  708,  741,  750,  637,  776,  785,  794,  797,  806,
      775,  827,  831,  843,  818,  819,  883,  415,    0,  712,
      399,  885,  352, 1252,    0,  191,    0,  202,  772,  170,
      243,  334,  222,  244,  247,  259,  766,   47,  209,  216,
      203,  251,  302,  892,  916,  890,  942,  715,  946,  958,
      930,  974,  274, 1252,   93,  344,  278,  310,  979,  256,
      264,  337,  270,  274,  352,  355,  215,  984,  995, 1000,
      299,  354,  589,  355,  223,  603,  209,  204,  198,  189,
      174,  101, 1004, 1016,   92,  634,  411,  644,  872, 1021,

      717,  373, 1252,  793,  832, 1252, 1055, 1065, 1081, 1086,
     1102, 1119, 1136, 1139, 1146,  339,  560, 1153, 1169, 1181,
     1186, 1197, 1200, 1216,  634,  645, 1223, 1234
    }

Definition at line 451 of file ada-lex.c.

YY_BUFFER_STATE* yy_buffer_stack = 0 [static]

Stack as an array.

Definition at line 264 of file ada-lex.c.

Referenced by yy_init_globals(), yyensure_buffer_stack(), and yylex_destroy().

size_t yy_buffer_stack_max = 0 [static]

capacity of stack.

Definition at line 263 of file ada-lex.c.

Referenced by yy_init_globals(), and yyensure_buffer_stack().

size_t yy_buffer_stack_top = 0 [static]

index of top of stack.

Definition at line 262 of file ada-lex.c.

Referenced by yy_init_globals(), yyensure_buffer_stack(), yypop_buffer_state(), and yypush_buffer_state().

char* yy_c_buf_p = (char *) 0 [static]

Definition at line 287 of file ada-lex.c.

Referenced by yy_init_globals(), and yypush_buffer_state().

yyconst flex_int16_t yy_chk[1320] [static]

Definition at line 658 of file ada-lex.c.

yyconst flex_int16_t yy_def[229] [static]
Initial value:
    {   0,
      206,    1,    1,    1,  206,  206,  206,  206,  207,  208,
      206,  206,  206,  206,  206,  206,  206,  209,  206,  206,
      206,  206,  210,  206,  206,  206,  211,  211,  211,  211,
      211,  211,  211,  211,   33,  211,   33,  206,  207,  206,
      207,  208,  212,   38,   38,  212,  206,  206,  212,  206,
      213,  209,  206,  214,  215,  215,  206,  216,  206,  206,
      206,  217,  206,  206,  206,  218,  206,  206,  206,  206,
      206,  219,  211,  211,  211,  211,  211,  211,  211,  211,
      211,  211,  211,  211,   36,  211,  211,   36,   33,   36,
       48,  220,  206,  206,  206,   48,  212,  213,  221,  215,

      215,  222,  206,  206,  206,  217,  218,  206,  219,  206,
      223,  224,  211,  211,   33,  211,  211,  211,  211,  211,
       33,  211,  211,  211,   33,   33,  211,  206,  225,  206,
      206,   97,  221,  206,  215,  206,  226,  222,  206,  206,
      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
      206,  206,  227,  224,  211,   33,  211,   36,  211,  211,
       36,  211,  206,  206,  212,  206,  228,  206,  206,  206,
      206,  206,  206,  206,  206,  206,  227,  211,  211,  211,
      212,  206,  206,  206,  228,  206,  206,  206,  206,  206,
      206,  206,  211,  211,  212,  206,  206,  206,  206,  206,

      206,  206,  206,  206,  206,    0,  206,  206,  206,  206,
      206,  206,  206,  206,  206,  206,  206,  206,  206,  206,
      206,  206,  206,  206,  206,  206,  206,  206
    }

Definition at line 480 of file ada-lex.c.

int yy_did_buffer_switch_on_eof [static]

Definition at line 294 of file ada-lex.c.

Referenced by yypop_buffer_state(), and yypush_buffer_state().

yyconst flex_int32_t yy_ec[256] [static]

Definition at line 408 of file ada-lex.c.

int yy_flex_debug = 0

Definition at line 811 of file ada-lex.c.

Referenced by yyget_debug().

char yy_hold_char [static]

Definition at line 282 of file ada-lex.c.

Referenced by yypush_buffer_state().

int yy_init = 0 [static]

Definition at line 288 of file ada-lex.c.

Referenced by yy_init_globals().

char* yy_last_accepting_cpos [static]

Definition at line 808 of file ada-lex.c.

yy_state_type yy_last_accepting_state [static]

Definition at line 807 of file ada-lex.c.

yyconst flex_int32_t yy_meta[68] [static]
Initial value:
    {   0,
        1,    2,    3,    4,    5,    6,    7,    8,    5,    9,
        5,    5,    5,    5,    5,    5,   10,    5,   11,   11,
        5,    5,   12,   13,   14,    5,   15,   15,   15,   15,
       15,   15,   16,   16,   16,   16,   16,   16,   16,   16,
       16,   16,   16,   16,   16,   16,    5,    5,   17,   15,
       15,   15,   15,   15,   16,   16,   16,   16,   16,   16,
       16,   16,   16,   16,   16,   16,   16
    }

Definition at line 440 of file ada-lex.c.

int yy_n_chars [static]

Definition at line 283 of file ada-lex.c.

Referenced by yypush_buffer_state().

yyconst flex_int16_t yy_nxt[1320] [static]

Definition at line 509 of file ada-lex.c.

int yy_start = 0 [static]

Definition at line 289 of file ada-lex.c.

Referenced by yy_init_globals().

FILE * yyin = (FILE *) 0

Definition at line 346 of file ada-lex.c.

Referenced by ada_parse(), yy_init_globals(), yyget_in(), and yyset_in().

int yyleng

Definition at line 284 of file ada-lex.c.

Referenced by rewind_to_char(), and yyget_leng().

int yylineno = 1

Definition at line 352 of file ada-lex.c.

Referenced by yyget_lineno().

FILE * yyout = (FILE *) 0

Definition at line 346 of file ada-lex.c.

Referenced by yy_init_globals(), yyget_out(), and yyset_out().

char* yytext

Definition at line 820 of file ada-lex.c.

Referenced by yyget_text().

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines
Generated on Fri Oct 11 2013 14:13:36 for GDB (xrefs) by   doxygen 1.7.6.1