From cf25a1d7a421b2aac2df52bfac1193dad68126df Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Mon, 24 Feb 2025 12:31:48 -0500 Subject: [PATCH 01/19] commented out the call to print function to stop seg fault for now --- runner.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runner.c b/runner.c index 93c9991..56fa776 100644 --- a/runner.c +++ b/runner.c @@ -87,7 +87,7 @@ int run(FILE *alpha) { if (st_flag != NULL) { //output symbol table, file pointer is - print_symbol_table(top,st_flag); + //print_symbol_table(top,st_flag); } if (yyin != NULL) { From 987a086daecf446b68b316dd074dbaca0aac56dd Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Tue, 25 Feb 2025 01:43:22 -0500 Subject: [PATCH 02/19] added initial block rules --- grammar.y | 7 + lex.yy.c | 2100 +++++++++++++++++++++++++++++++++++++++++++++++++++++ runner | Bin 0 -> 31656 bytes runner.c | 2 +- 4 files changed, 2108 insertions(+), 1 deletion(-) create mode 100644 lex.yy.c create mode 100755 runner diff --git a/grammar.y b/grammar.y index 591d80a..0acc0c9 100644 --- a/grammar.y +++ b/grammar.y @@ -53,5 +53,12 @@ %token RELEASE 614 %token COMMENT 700 %% +B : '{' E '}'; //Braced Expressions can have braces removed to get regular expressions +D : '[' l ']'; //Declaration Lists Brackets can be taken out to get a list of Declarations +E : Maybe_D U; //An expression can start with an optional D followed by an undeclared segment +Maybe_D : D + | ; //Either D or not +l : A ';' l; + | ; //a declaration list can either be empty or be an assignment followed by a semi-colon and another list %% diff --git a/lex.yy.c b/lex.yy.c new file mode 100644 index 0000000..c4dad48 --- /dev/null +++ b/lex.yy.c @@ -0,0 +1,2100 @@ +#line 2 "lex.yy.c" + +#line 4 "lex.yy.c" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. + */ +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN (yy_start) = 1 + 2 * +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START (((yy_start) - 1) / 2) +#define YYSTATE YY_START +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +extern int yyleng; + +extern FILE *yyin, *yyout; + +#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 YY_LINENO_REWIND_TO(ptr) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + 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 ) +#define unput(c) yyunput( c, (yytext_ptr) ) + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = NULL; +static int yy_init = 0; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +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 ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); + +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); + +#define yy_new_buffer yy_create_buffer +#define yy_set_interactive(is_interactive) \ + { \ + 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; \ + } +#define yy_set_bol(at_bol) \ + { \ + 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; \ + } +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ + +#define yywrap() (/*CONSTCOND*/1) +#define YY_SKIP_YYWRAP +typedef flex_uint8_t YY_CHAR; + +FILE *yyin = NULL, *yyout = NULL; + +typedef int yy_state_type; + +extern int yylineno; +int yylineno = 1; + +extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif +#define yytext_ptr yytext + +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 yynoreturn yy_fatal_error ( const char* msg ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ + (yy_c_buf_p) = yy_cp; +#define YY_NUM_RULES 50 +#define YY_END_OF_BUFFER 51 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static const flex_int16_t yy_accept[147] = + { 0, + 0, 0, 51, 49, 47, 46, 48, 24, 49, 20, + 25, 49, 36, 37, 18, 16, 30, 17, 27, 19, + 32, 29, 28, 21, 22, 45, 45, 38, 39, 45, + 45, 45, 45, 45, 45, 45, 45, 45, 40, 26, + 41, 0, 34, 0, 0, 0, 0, 31, 32, 23, + 45, 45, 45, 13, 45, 45, 45, 45, 45, 6, + 45, 45, 45, 45, 45, 45, 45, 33, 0, 0, + 0, 45, 45, 45, 45, 45, 45, 45, 45, 45, + 45, 45, 45, 45, 45, 45, 45, 0, 0, 0, + 35, 0, 45, 45, 45, 8, 45, 45, 45, 45, + + 44, 45, 45, 45, 7, 42, 9, 45, 0, 35, + 0, 0, 45, 45, 45, 45, 43, 45, 45, 45, + 45, 45, 5, 0, 45, 45, 45, 45, 45, 45, + 45, 45, 11, 3, 2, 45, 45, 45, 1, 14, + 15, 45, 12, 10, 4, 0 + } ; + +static const YY_CHAR yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 4, 5, 6, 1, 1, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 18, 18, + 18, 18, 18, 18, 18, 18, 18, 19, 20, 21, + 22, 23, 1, 1, 24, 25, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 26, 27, 28, 1, 24, 1, 29, 24, 30, 31, + + 32, 33, 34, 35, 36, 24, 24, 37, 24, 38, + 39, 40, 24, 41, 42, 43, 44, 45, 46, 47, + 48, 24, 49, 50, 51, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static const YY_CHAR yy_meta[52] = + { 0, + 1, 2, 3, 1, 1, 1, 1, 1, 2, 1, + 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, + 1, 1, 1, 4, 4, 1, 1, 1, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, + 1 + } ; + +static const flex_int16_t yy_base[156] = + { 0, + 0, 0, 203, 204, 204, 204, 204, 204, 46, 204, + 204, 175, 189, 204, 204, 204, 204, 177, 204, 204, + 181, 176, 204, 204, 204, 0, 158, 204, 204, 22, + 161, 18, 25, 23, 151, 162, 22, 158, 204, 204, + 204, 52, 204, 53, 183, 51, 55, 204, 173, 204, + 0, 151, 158, 0, 159, 145, 143, 148, 146, 0, + 140, 145, 34, 149, 136, 139, 142, 204, 63, 165, + 69, 139, 134, 133, 141, 140, 129, 140, 137, 131, + 135, 134, 121, 126, 131, 130, 124, 71, 73, 75, + 204, 81, 128, 127, 129, 0, 116, 124, 112, 120, + + 0, 124, 111, 110, 0, 0, 0, 118, 86, 204, + 88, 90, 120, 106, 117, 108, 0, 109, 112, 101, + 97, 103, 0, 92, 102, 97, 95, 108, 72, 69, + 75, 63, 0, 0, 0, 58, 51, 34, 0, 0, + 0, 27, 0, 0, 0, 204, 104, 108, 58, 112, + 116, 120, 124, 128, 132 + } ; + +static const flex_int16_t yy_def[156] = + { 0, + 146, 1, 146, 146, 146, 146, 146, 146, 147, 146, + 146, 148, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 149, 149, 146, 146, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 146, 146, + 146, 147, 146, 146, 146, 146, 150, 146, 146, 146, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 146, 150, 151, + 152, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 150, 153, 154, + 146, 152, 149, 149, 149, 149, 149, 149, 149, 149, + + 149, 149, 149, 149, 149, 149, 149, 149, 155, 146, + 153, 154, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 155, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 0, 146, 146, 146, 146, + 146, 146, 146, 146, 146 + } ; + +static const flex_int16_t yy_nxt[256] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 4, 26, 27, 28, 4, 29, 30, 31, + 26, 32, 33, 26, 26, 34, 26, 35, 26, 26, + 36, 26, 37, 26, 26, 38, 26, 26, 39, 40, + 41, 43, 53, 58, 56, 60, 64, 43, 42, 45, + 61, 51, 65, 54, 57, 70, 71, 145, 59, 66, + 81, 144, 44, 88, 71, 82, 83, 45, 44, 91, + 92, 88, 71, 110, 111, 88, 71, 143, 45, 142, + 42, 110, 92, 45, 141, 42, 70, 89, 146, 111, + + 88, 71, 70, 89, 42, 42, 140, 42, 45, 139, + 138, 45, 69, 69, 69, 69, 70, 70, 70, 70, + 90, 90, 90, 90, 109, 109, 109, 109, 112, 112, + 112, 112, 124, 124, 124, 124, 137, 136, 135, 134, + 133, 132, 131, 130, 129, 128, 127, 126, 125, 123, + 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, + 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, + 98, 97, 96, 95, 94, 93, 89, 87, 86, 85, + 84, 80, 79, 78, 77, 76, 75, 74, 73, 72, + 49, 68, 67, 63, 62, 55, 52, 50, 49, 48, + + 47, 46, 146, 3, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146 + } ; + +static const flex_int16_t yy_chk[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 9, 30, 33, 32, 34, 37, 42, 44, 46, + 34, 149, 37, 30, 32, 47, 47, 142, 33, 37, + 63, 138, 9, 69, 69, 63, 63, 46, 42, 71, + 71, 88, 88, 89, 89, 90, 90, 137, 46, 136, + 44, 92, 92, 46, 132, 44, 109, 109, 111, 111, + + 112, 112, 124, 124, 147, 147, 131, 147, 148, 130, + 129, 148, 150, 150, 150, 150, 151, 151, 151, 151, + 152, 152, 152, 152, 153, 153, 153, 153, 154, 154, + 154, 154, 155, 155, 155, 155, 128, 127, 126, 125, + 122, 121, 120, 119, 118, 116, 115, 114, 113, 108, + 104, 103, 102, 100, 99, 98, 97, 95, 94, 93, + 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, + 77, 76, 75, 74, 73, 72, 70, 67, 66, 65, + 64, 62, 61, 59, 58, 57, 56, 55, 53, 52, + 49, 45, 38, 36, 35, 31, 27, 22, 21, 18, + + 13, 12, 3, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +extern int yy_flex_debug; +int yy_flex_debug = 0; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#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 +char *yytext; +#line 1 "lexicalStructure.lex" +/* Lexical Analysis with Flex (1.6.0) We used some of the code from this manual */ +/* so we placed the citation here. */ +/* definitions */ +#line 8 "lexicalStructure.lex" + #include + #include "typedefs.h" + int line_number = 1, column_number = 1; + #ifndef DEBUG + #define DEBUG 0 + #endif +#line 561 "lex.yy.c" +#line 22 "lexicalStructure.lex" + /* char can be a newline, tab, an escaped quote, or anything but a single quote, an actual line break, an actual tab, or a backslash by itself (to prevent confusion from escaped quote */ + /* similar to above, a string Char (SCHAR) is the same as a CHAR except we cannot have double quotes instead of single quotes. Double quotes need to be escaped in Flex unlike single quotes based on documentation */ +#line 565 "lex.yy.c" + +#define INITIAL 0 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +static int yy_init_globals ( void ); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +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 ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( void ); +#else +extern int yywrap ( void ); +#endif +#endif + +#ifndef YY_NO_UNPUT + + static void yyunput ( int c, char *buf_ptr ); + +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * ); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput ( void ); +#else +static int input ( void ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + int n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex (void); + +#define YY_DECL int yylex (void) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK /*LINTED*/break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_load_buffer_state( ); + } + + { +#line 26 "lexicalStructure.lex" + + +#line 785 "lex.yy.c" + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ + { + yy_cp = (yy_c_buf_p); + + /* Support of yytext. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = (yy_start); +yy_match: + do + { + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 147 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 204 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 28 "lexicalStructure.lex" +{if(DEBUG) {printf( "T_INTEGER: %s (%d)\n", yytext, T_INTEGER);} else {return T_INTEGER;}} + YY_BREAK +case 2: +YY_RULE_SETUP +#line 29 "lexicalStructure.lex" +{if(DEBUG) {printf( "T_ADDRESS: %s (%d)\n", yytext, T_ADDRESS);} else {return T_ADDRESS;}} + YY_BREAK +case 3: +YY_RULE_SETUP +#line 30 "lexicalStructure.lex" +{if(DEBUG) {printf( "T_BOOLEAN: %s (%d)\n", yytext, T_BOOLEAN);} else {return T_BOOLEAN;}} + YY_BREAK +case 4: +YY_RULE_SETUP +#line 31 "lexicalStructure.lex" +{if(DEBUG) {printf( "T_CHARACTER: %s (%d)\n", yytext, T_CHARACTER);} else {return T_CHARACTER;}} + YY_BREAK +case 5: +YY_RULE_SETUP +#line 33 "lexicalStructure.lex" +{if(DEBUG) {printf( "WHILE: %s (%d)\n", yytext, WHILE);} else {return WHILE;}} + YY_BREAK +case 6: +YY_RULE_SETUP +#line 34 "lexicalStructure.lex" +{if(DEBUG) {printf( "IF: %s (%d)\n", yytext, IF);} else {return IF;}} + YY_BREAK +case 7: +YY_RULE_SETUP +#line 35 "lexicalStructure.lex" +{if(DEBUG) {printf( "THEN: %s (%d)\n", yytext, THEN);} else {return THEN;}} + YY_BREAK +case 8: +YY_RULE_SETUP +#line 36 "lexicalStructure.lex" +{if(DEBUG) {printf( "ELSE: %s (%d)\n", yytext, ELSE);} else {return ELSE;}} + YY_BREAK +case 9: +YY_RULE_SETUP +#line 37 "lexicalStructure.lex" +{if(DEBUG) {printf( "TYPE: %s (%d)\n", yytext, TYPE);} else {return TYPE;}} + YY_BREAK +case 10: +YY_RULE_SETUP +#line 38 "lexicalStructure.lex" +{if(DEBUG) {printf( "FUNCTION: %s (%d)\n", yytext, FUNCTION);} else {return FUNCTION;}} + YY_BREAK +case 11: +YY_RULE_SETUP +#line 39 "lexicalStructure.lex" +{if(DEBUG) {printf( "RETURN: %s (%d)\n", yytext, RETURN);} else {return RETURN;}} + YY_BREAK +case 12: +YY_RULE_SETUP +#line 40 "lexicalStructure.lex" +{if(DEBUG) {printf( "EXTERNAL: %s (%d)\n", yytext, EXTERNAL);} else {return EXTERNAL;}} + YY_BREAK +case 13: +YY_RULE_SETUP +#line 41 "lexicalStructure.lex" +{if(DEBUG) {printf( "AS: %s (%d)\n", yytext, AS);} else {return AS;}} + YY_BREAK +case 14: +YY_RULE_SETUP +#line 43 "lexicalStructure.lex" +{if(DEBUG) {printf( "RELEASE: %s (%d)\n", yytext, RELEASE);} else {return RELEASE;}} + YY_BREAK +case 15: +YY_RULE_SETUP +#line 44 "lexicalStructure.lex" +{if(DEBUG) {printf( "RESERVE: %s (%d)\n", yytext, RESERVE);} else {return RESERVE;}} + YY_BREAK +case 16: +YY_RULE_SETUP +#line 46 "lexicalStructure.lex" +{if(DEBUG) {printf( "ADD: %s (%d)\n", yytext, ADD);} else {return ADD;}} + YY_BREAK +case 17: +YY_RULE_SETUP +#line 47 "lexicalStructure.lex" +{if(DEBUG) {printf( "SUB_OR_NEG: %s (%d)\n", yytext, SUB_OR_NEG);} else {return SUB_OR_NEG;}} + YY_BREAK +case 18: +YY_RULE_SETUP +#line 48 "lexicalStructure.lex" +{if(DEBUG) {printf( "MUL: %s (%d)\n", yytext, MUL);} else {return MUL;}} + YY_BREAK +case 19: +YY_RULE_SETUP +#line 49 "lexicalStructure.lex" +{if(DEBUG) {printf( "DIV: %s (%d)\n", yytext, DIV);} else {return DIV;}} + YY_BREAK +case 20: +YY_RULE_SETUP +#line 50 "lexicalStructure.lex" +{if(DEBUG) {printf( "REM: %s (%d)\n", yytext, REM);} else {return REM;}} + YY_BREAK +case 21: +YY_RULE_SETUP +#line 51 "lexicalStructure.lex" +{if(DEBUG) {printf( "LESS_THAN: %s (%d)\n", yytext, LESS_THAN);} else {return LESS_THAN;}} + YY_BREAK +case 22: +YY_RULE_SETUP +#line 52 "lexicalStructure.lex" +{if(DEBUG) {printf( "EQUAL_TO: %s (%d)\n", yytext, EQUAL_TO);} else {return EQUAL_TO;}} + YY_BREAK +case 23: +YY_RULE_SETUP +#line 53 "lexicalStructure.lex" +{if(DEBUG) {printf( "ASSIGN: %s (%d)\n", yytext, ASSIGN);} else {return ASSIGN;}} + YY_BREAK +case 24: +YY_RULE_SETUP +#line 54 "lexicalStructure.lex" +{if(DEBUG) {printf( "NOT: %s (%d)\n", yytext, NOT);} else {return NOT;}} + YY_BREAK +case 25: +YY_RULE_SETUP +#line 55 "lexicalStructure.lex" +{if(DEBUG) {printf( "AND: %s (%d)\n", yytext, AND);} else {return AND;}} + YY_BREAK +case 26: +YY_RULE_SETUP +#line 56 "lexicalStructure.lex" +{if(DEBUG) {printf( "OR: %s (%d)\n", yytext, OR);} else {return OR;}} + YY_BREAK +case 27: +YY_RULE_SETUP +#line 57 "lexicalStructure.lex" +{if(DEBUG) {printf( "DOT: %s (%d)\n", yytext, DOT);} else {return DOT;}} + YY_BREAK +case 28: +YY_RULE_SETUP +#line 59 "lexicalStructure.lex" +{if(DEBUG) {printf( "SEMI_COLON: %s (%d)\n", yytext, SEMI_COLON);} else {return SEMI_COLON;}} + YY_BREAK +case 29: +YY_RULE_SETUP +#line 60 "lexicalStructure.lex" +{if(DEBUG) {printf( "COLON: %s (%d)\n", yytext, COLON);} else {return COLON;}} + YY_BREAK +case 30: +YY_RULE_SETUP +#line 61 "lexicalStructure.lex" +{if(DEBUG) {printf( "COMMA: %s (%d)\n", yytext, COMMA);} else {return COMMA;}} + YY_BREAK +case 31: +YY_RULE_SETUP +#line 62 "lexicalStructure.lex" +{if(DEBUG) {printf( "ARROW: %s (%d)\n", yytext, ARROW);} else {return ARROW;}} + YY_BREAK +case 32: +YY_RULE_SETUP +#line 64 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_INTEGER: %s (%d)\n", yytext, C_INTEGER);} else {return C_INTEGER;}} + YY_BREAK +case 33: +YY_RULE_SETUP +#line 65 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_CHARACTER: %s (%d)\n", yytext, C_CHARACTER);} else {return C_CHARACTER;}} + YY_BREAK +case 34: +YY_RULE_SETUP +#line 66 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_STRING: %s (%d)\n", yytext, C_STRING);} else {return C_STRING;}} + YY_BREAK +case 35: +/* rule 35 can match eol */ +YY_RULE_SETUP +#line 67 "lexicalStructure.lex" +{if(DEBUG) {printf( "COMMENT: %s (%d)\n", yytext, COMMENT);} else {return COMMENT;}} + YY_BREAK +case 36: +YY_RULE_SETUP +#line 69 "lexicalStructure.lex" +{if(DEBUG) {printf( "L_PAREN: %s (%d)\n", yytext, L_PAREN);} else {return L_PAREN;}} + YY_BREAK +case 37: +YY_RULE_SETUP +#line 70 "lexicalStructure.lex" +{if(DEBUG) {printf( "R_PAREN: %s (%d)\n", yytext, R_PAREN);} else {return R_PAREN;}} + YY_BREAK +case 38: +YY_RULE_SETUP +#line 72 "lexicalStructure.lex" +{if(DEBUG) {printf( "L_BRACKET: %s (%d)\n", yytext, L_BRACKET);} else {return L_BRACKET;}} + YY_BREAK +case 39: +YY_RULE_SETUP +#line 73 "lexicalStructure.lex" +{if(DEBUG) {printf( "R_BRACKET: %s (%d)\n", yytext, R_BRACKET);} else {return R_BRACKET;}} + YY_BREAK +case 40: +YY_RULE_SETUP +#line 75 "lexicalStructure.lex" +{if(DEBUG) {printf( "L_BRACE: %s (%d)\n", yytext, L_BRACE);} else {return L_BRACE;}} + YY_BREAK +case 41: +YY_RULE_SETUP +#line 76 "lexicalStructure.lex" +{if(DEBUG) {printf( "R_BRACE: %s (%d)\n", yytext, R_BRACE);} else {return R_BRACE;}} + YY_BREAK +case 42: +YY_RULE_SETUP +#line 78 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_TRUE: %s (%d)\n", yytext, C_TRUE);} else {return C_TRUE;}} + YY_BREAK +case 43: +YY_RULE_SETUP +#line 79 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_FALSE: %s (%d)\n", yytext, C_FALSE);} else {return C_FALSE;}} + YY_BREAK +case 44: +YY_RULE_SETUP +#line 80 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_NULL: %s (%d)\n", yytext, C_NULL);} else {return C_NULL;}} + YY_BREAK +case 45: +YY_RULE_SETUP +#line 82 "lexicalStructure.lex" +{if(DEBUG) {printf( "ID: %s (%d)\n", yytext, ID);} else {return ID;}} + YY_BREAK +case 46: +/* rule 46 can match eol */ +YY_RULE_SETUP +#line 84 "lexicalStructure.lex" +{line_number++; column_number = 1;} + YY_BREAK +case 47: +YY_RULE_SETUP +#line 85 "lexicalStructure.lex" +{column_number++;} + YY_BREAK +case 48: +YY_RULE_SETUP +#line 86 "lexicalStructure.lex" +{column_number++;} + YY_BREAK +case 49: +YY_RULE_SETUP +#line 87 "lexicalStructure.lex" +{column_number++; return 1999;} + YY_BREAK +case 50: +YY_RULE_SETUP +#line 89 "lexicalStructure.lex" +ECHO; + YY_BREAK +#line 1094 "lex.yy.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = (yy_c_buf_p); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of user's declarations */ +} /* end of yylex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (void) +{ + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = (yytext_ptr); + int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (void) +{ + yy_state_type yy_current_state; + char *yy_cp; + + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 147 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +{ + int yy_is_jam; + char *yy_cp = (yy_c_buf_p); + + YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 147 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 146); + + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_UNPUT + + static void yyunput (int c, char * yy_bp ) +{ + char *yy_cp; + + yy_cp = (yy_c_buf_p); + + /* undo effects of setting up yytext */ + *yy_cp = (yy_hold_char); + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + int number_to_move = (yy_n_chars) + 2; + char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; + char *source = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; + + while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = + (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + (yytext_ptr) = yy_bp; + (yy_hold_char) = *yy_cp; + (yy_c_buf_p) = yy_cp; +} + +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (void) +#else + static int input (void) +#endif + +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( ) ) + return 0; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyrestart (FILE * input_file ) +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + +static void yy_load_buffer_state (void) +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + (yy_hold_char) = *(yy_c_buf_p); +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ + void yy_delete_buffer (YY_BUFFER_STATE b ) +{ + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree( (void *) b->yy_ch_buf ); + + yyfree( (void *) b ); +} + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) + +{ + int oerrno = errno; + + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ + void yy_flush_buffer (YY_BUFFER_STATE b ) +{ + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +void yypop_buffer_state (void) +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void yyensure_buffer_stack (void) +{ + yy_size_t num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + yy_size_t grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return NULL; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = NULL; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (const char * yystr ) +{ + + return yy_scan_bytes( yystr, (int) strlen(yystr) ); +} + +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yynoreturn yy_fatal_error (const char* msg ) +{ + fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + 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 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the current line number. + * + */ +int yyget_lineno (void) +{ + + return yylineno; +} + +/** Get the input stream. + * + */ +FILE *yyget_in (void) +{ + return yyin; +} + +/** Get the output stream. + * + */ +FILE *yyget_out (void) +{ + return yyout; +} + +/** Get the length of the current token. + * + */ +int yyget_leng (void) +{ + return yyleng; +} + +/** Get the current token. + * + */ + +char *yyget_text (void) +{ + return yytext; +} + +/** Set the current line number. + * @param _line_number line number + * + */ +void yyset_lineno (int _line_number ) +{ + + yylineno = _line_number; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param _in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * _in_str ) +{ + yyin = _in_str ; +} + +void yyset_out (FILE * _out_str ) +{ + yyout = _out_str ; +} + +int yyget_debug (void) +{ + return yy_flex_debug; +} + +void yyset_debug (int _bdebug ) +{ + yy_flex_debug = _bdebug ; +} + +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + (yy_buffer_stack) = NULL; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = NULL; + (yy_init) = 0; + (yy_start) = 0; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = NULL; + yyout = NULL; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} + +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer( YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } + + /* Destroy the stack itself. */ + yyfree((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( ); + + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, const char * s2, int n ) +{ + + int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (const char * s ) +{ + int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size ) +{ + return malloc(size); +} + +void *yyrealloc (void * ptr, yy_size_t size ) +{ + + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return realloc(ptr, size); +} + +void yyfree (void * ptr ) +{ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 89 "lexicalStructure.lex" + + diff --git a/runner b/runner new file mode 100755 index 0000000000000000000000000000000000000000..6fa219f4df413b87ee586177c95df0f39c987b44 GIT binary patch literal 31656 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 Y77 Date: Wed, 26 Feb 2025 11:58:46 -0500 Subject: [PATCH 03/19] added more symbol table functions --- grammar.y | 3 ++- runner.c | 3 ++- symbol_table.c | 31 +++++++++++++++++++++++++++++++ symbol_table.h | 10 +++++----- test_keywords.st | 0 test_operators.st | 0 test_real_alpha_2.st | 0 7 files changed, 40 insertions(+), 7 deletions(-) create mode 100644 test_keywords.st create mode 100644 test_operators.st create mode 100644 test_real_alpha_2.st diff --git a/grammar.y b/grammar.y index 0acc0c9..d930f2a 100644 --- a/grammar.y +++ b/grammar.y @@ -4,6 +4,7 @@ // Prologue %{ #include + #include "symbol_table.c" %} %token ID 101 @@ -53,7 +54,7 @@ %token RELEASE 614 %token COMMENT 700 %% -B : '{' E '}'; //Braced Expressions can have braces removed to get regular expressions +B : '{'{CreateScope(cur,line,column)} E '}'; //Braced Expressions can have braces removed to get regular expressions D : '[' l ']'; //Declaration Lists Brackets can be taken out to get a list of Declarations E : Maybe_D U; //An expression can start with an optional D followed by an undeclared segment Maybe_D : D diff --git a/runner.c b/runner.c index 435cd24..a2be6b6 100644 --- a/runner.c +++ b/runner.c @@ -81,7 +81,8 @@ int run(FILE *alpha) { } if(token == 1999){ printf("On line number %d and column number %d we have an invalid character:%s\n",line_number,column_number,yytext); - return -1;} + //return -1; +} column_number += yyleng; } diff --git a/symbol_table.c b/symbol_table.c index e87ebd8..2a7729f 100644 --- a/symbol_table.c +++ b/symbol_table.c @@ -101,6 +101,37 @@ void print_symbol_table(SymbolTable *table, FILE *file_ptr){ } } +SymbolTable * getParent(SymbolTable* st){ + return st->ParentScope; + } + +ListOfTable * getChildren(SymbolTable* st){ + return st->Children_Scope; + } +SymbolTable * getFirstChild(ListOfTable * lt){ + return lt->table; + } +ListOfTable * getRestOfChildren(ListOfTable * lt){ + return lt->next; + } +TableNode * getFirstEntry(SymbolTable * st){ + return st->entries; + } +TableNode * getNextEntry(TableNode * tn){ + return tn->next; + } +char * getType(TableNode * tn){ + return tn->theType; + } +char * getName(TableNode * tn){ + return tn->theName; + } +int getLine(SymbolTable * st){ + return st->line; + } +int getColumn(SymbolTable *st){ + return st->column; + } //uncomment the below main function along with the headers above for a simple standalone test of table and entry creation /* diff --git a/symbol_table.h b/symbol_table.h index 57ae1bc..0d30f59 100644 --- a/symbol_table.h +++ b/symbol_table.h @@ -17,11 +17,11 @@ typedef struct TableNode{ }TableNode; typedef struct SymbolTable{ - TableNode* entries; - struct SymbolTable* Parent_Scope; - struct ListOfTable* Children_Scope; - int Line_Number; - int Column_Number; + TableNode* entries; + struct SymbolTable* Parent_Scope; + struct ListOfTable* Children_Scope; + int Line_Number; + int Column_Number; }SymbolTable; diff --git a/test_keywords.st b/test_keywords.st new file mode 100644 index 0000000..e69de29 diff --git a/test_operators.st b/test_operators.st new file mode 100644 index 0000000..e69de29 diff --git a/test_real_alpha_2.st b/test_real_alpha_2.st new file mode 100644 index 0000000..e69de29 From 046ccf194b8e75a7e306a68f12f5e59c062a9b14 Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Wed, 26 Feb 2025 12:52:29 -0500 Subject: [PATCH 04/19] edited symbol table functions --- grammar.y | 22 +++++++++++++++------- lex.yy.c | 11 +++++------ symbol_table.c | 6 +++--- test_keywords.st | 0 test_operators.st | 0 test_real_alpha_2.st | 0 6 files changed, 23 insertions(+), 16 deletions(-) delete mode 100644 test_keywords.st delete mode 100644 test_operators.st delete mode 100644 test_real_alpha_2.st diff --git a/grammar.y b/grammar.y index d930f2a..172058c 100644 --- a/grammar.y +++ b/grammar.y @@ -54,12 +54,20 @@ %token RELEASE 614 %token COMMENT 700 %% -B : '{'{CreateScope(cur,line,column)} E '}'; //Braced Expressions can have braces removed to get regular expressions -D : '[' l ']'; //Declaration Lists Brackets can be taken out to get a list of Declarations -E : Maybe_D U; //An expression can start with an optional D followed by an undeclared segment -Maybe_D : D - | ; //Either D or not -l : A ';' l; - | ; //a declaration list can either be empty or be an assignment followed by a semi-colon and another list + +start: /*empty for now*/ + ; +// B : '{'{CreateScope(cur,line,column)} E '}'; //Braced Expressions can have braces removed to get regular expressions +// D : '[' l ']'; //Declaration Lists Brackets can be taken out to get a list of Declarations +// E : Maybe_D U; //An expression can start with an optional D followed by an undeclared segment +// Maybe_D : D +// | ; //Either D or not +//l : A ';' l; +// | ; //a declaration list can either be empty or be an assignment followed by a semi-colon and another list %% + +int main() { + return yyparse(); +} + diff --git a/lex.yy.c b/lex.yy.c index c4dad48..49b4eed 100644 --- a/lex.yy.c +++ b/lex.yy.c @@ -1,6 +1,5 @@ -#line 2 "lex.yy.c" -#line 4 "lex.yy.c" +#line 3 "lex.yy.c" #define YY_INT_ALIGNED short int @@ -557,11 +556,11 @@ char *yytext; #ifndef DEBUG #define DEBUG 0 #endif -#line 561 "lex.yy.c" +#line 560 "lex.yy.c" #line 22 "lexicalStructure.lex" /* char can be a newline, tab, an escaped quote, or anything but a single quote, an actual line break, an actual tab, or a backslash by itself (to prevent confusion from escaped quote */ /* similar to above, a string Char (SCHAR) is the same as a CHAR except we cannot have double quotes instead of single quotes. Double quotes need to be escaped in Flex unlike single quotes based on documentation */ -#line 565 "lex.yy.c" +#line 564 "lex.yy.c" #define INITIAL 0 @@ -781,7 +780,7 @@ YY_DECL #line 26 "lexicalStructure.lex" -#line 785 "lex.yy.c" +#line 784 "lex.yy.c" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { @@ -1090,7 +1089,7 @@ YY_RULE_SETUP #line 89 "lexicalStructure.lex" ECHO; YY_BREAK -#line 1094 "lex.yy.c" +#line 1093 "lex.yy.c" case YY_STATE_EOF(INITIAL): yyterminate(); diff --git a/symbol_table.c b/symbol_table.c index 2a7729f..11ba544 100644 --- a/symbol_table.c +++ b/symbol_table.c @@ -102,7 +102,7 @@ void print_symbol_table(SymbolTable *table, FILE *file_ptr){ } SymbolTable * getParent(SymbolTable* st){ - return st->ParentScope; + return st->Parent_Scope; } ListOfTable * getChildren(SymbolTable* st){ @@ -127,10 +127,10 @@ char * getName(TableNode * tn){ return tn->theName; } int getLine(SymbolTable * st){ - return st->line; + return st->Line_Number; } int getColumn(SymbolTable *st){ - return st->column; + return st->Column_Number; } //uncomment the below main function along with the headers above for a simple standalone test of table and entry creation diff --git a/test_keywords.st b/test_keywords.st deleted file mode 100644 index e69de29..0000000 diff --git a/test_operators.st b/test_operators.st deleted file mode 100644 index e69de29..0000000 diff --git a/test_real_alpha_2.st b/test_real_alpha_2.st deleted file mode 100644 index e69de29..0000000 From 3ce8cbae59a3d6568f36ad2cbfbf7eed2f8c26f1 Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Wed, 26 Feb 2025 15:57:08 -0500 Subject: [PATCH 05/19] Parser compiles from .y and .lex files --- grammar.y | 10 +- lex.yy.c | 2099 ------------------------------------------ lexicalStructure.lex | 1 + parser | Bin 0 -> 36568 bytes 4 files changed, 8 insertions(+), 2102 deletions(-) delete mode 100644 lex.yy.c create mode 100755 parser diff --git a/grammar.y b/grammar.y index 172058c..2bd520d 100644 --- a/grammar.y +++ b/grammar.y @@ -5,8 +5,10 @@ %{ #include #include "symbol_table.c" + extern int yylex(void); + void yyerror(const char *err); %} - +/* %token ID 101 %token T_INTEGER 201 %token T_ADDRESS 202 @@ -52,7 +54,7 @@ %token DOT 612 %token RESERVE 613 %token RELEASE 614 -%token COMMENT 700 +%token COMMENT 700 */ %% start: /*empty for now*/ @@ -67,7 +69,9 @@ start: /*empty for now*/ %% +void yyerror(const char *err) { + fprintf(stderr, "Error: %s\n", err); +} int main() { return yyparse(); } - diff --git a/lex.yy.c b/lex.yy.c deleted file mode 100644 index 49b4eed..0000000 --- a/lex.yy.c +++ /dev/null @@ -1,2099 +0,0 @@ - -#line 3 "lex.yy.c" - -#define YY_INT_ALIGNED short int - -/* A lexical scanner generated by flex */ - -#define FLEX_SCANNER -#define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 6 -#define YY_FLEX_SUBMINOR_VERSION 4 -#if YY_FLEX_SUBMINOR_VERSION > 0 -#define FLEX_BETA -#endif - -/* First, we deal with platform-specific or compiler-specific issues. */ - -/* begin standard C headers. */ -#include -#include -#include -#include - -/* end standard C headers. */ - -/* flex integer type definitions */ - -#ifndef FLEXINT_H -#define FLEXINT_H - -/* C99 systems have . Non-C99 systems may or may not. */ - -#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - -/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. - */ -#ifndef __STDC_LIMIT_MACROS -#define __STDC_LIMIT_MACROS 1 -#endif - -#include -typedef int8_t flex_int8_t; -typedef uint8_t flex_uint8_t; -typedef int16_t flex_int16_t; -typedef uint16_t flex_uint16_t; -typedef int32_t flex_int32_t; -typedef uint32_t flex_uint32_t; -#else -typedef signed char flex_int8_t; -typedef short int flex_int16_t; -typedef int flex_int32_t; -typedef unsigned char flex_uint8_t; -typedef unsigned short int flex_uint16_t; -typedef unsigned int flex_uint32_t; - -/* Limits of integral types. */ -#ifndef INT8_MIN -#define INT8_MIN (-128) -#endif -#ifndef INT16_MIN -#define INT16_MIN (-32767-1) -#endif -#ifndef INT32_MIN -#define INT32_MIN (-2147483647-1) -#endif -#ifndef INT8_MAX -#define INT8_MAX (127) -#endif -#ifndef INT16_MAX -#define INT16_MAX (32767) -#endif -#ifndef INT32_MAX -#define INT32_MAX (2147483647) -#endif -#ifndef UINT8_MAX -#define UINT8_MAX (255U) -#endif -#ifndef UINT16_MAX -#define UINT16_MAX (65535U) -#endif -#ifndef UINT32_MAX -#define UINT32_MAX (4294967295U) -#endif - -#ifndef SIZE_MAX -#define SIZE_MAX (~(size_t)0) -#endif - -#endif /* ! C99 */ - -#endif /* ! FLEXINT_H */ - -/* begin standard C++ headers. */ - -/* TODO: this is always defined, so inline it */ -#define yyconst const - -#if defined(__GNUC__) && __GNUC__ >= 3 -#define yynoreturn __attribute__((__noreturn__)) -#else -#define yynoreturn -#endif - -/* Returned upon end-of-file. */ -#define YY_NULL 0 - -/* Promotes a possibly negative, possibly signed char to an - * integer in range [0..255] for use as an array index. - */ -#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) - -/* Enter a start condition. This macro really ought to take a parameter, - * but we do it the disgusting crufty way forced on us by the ()-less - * definition of BEGIN. - */ -#define BEGIN (yy_start) = 1 + 2 * -/* Translate the current start state into a value that can be later handed - * to BEGIN to return to the state. The YYSTATE alias is for lex - * compatibility. - */ -#define YY_START (((yy_start) - 1) / 2) -#define YYSTATE YY_START -/* Action number for EOF rule of a given start state. */ -#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) -/* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE yyrestart( yyin ) -#define YY_END_OF_BUFFER_CHAR 0 - -/* Size of default input buffer. */ -#ifndef YY_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k. - * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. - * Ditto for the __ia64__ case accordingly. - */ -#define YY_BUF_SIZE 32768 -#else -#define YY_BUF_SIZE 16384 -#endif /* __ia64__ */ -#endif - -/* The state buf must be large enough to hold one state per character in the main buffer. - */ -#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) - -#ifndef YY_TYPEDEF_YY_BUFFER_STATE -#define YY_TYPEDEF_YY_BUFFER_STATE -typedef struct yy_buffer_state *YY_BUFFER_STATE; -#endif - -#ifndef YY_TYPEDEF_YY_SIZE_T -#define YY_TYPEDEF_YY_SIZE_T -typedef size_t yy_size_t; -#endif - -extern int yyleng; - -extern FILE *yyin, *yyout; - -#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 YY_LINENO_REWIND_TO(ptr) - -/* Return all but the first "n" matched characters back to the input stream. */ -#define yyless(n) \ - 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 ) -#define unput(c) yyunput( c, (yytext_ptr) ) - -#ifndef YY_STRUCT_YY_BUFFER_STATE -#define YY_STRUCT_YY_BUFFER_STATE -struct yy_buffer_state - { - FILE *yy_input_file; - - char *yy_ch_buf; /* input buffer */ - char *yy_buf_pos; /* current position in input buffer */ - - /* Size of input buffer in bytes, not including room for EOB - * characters. - */ - int yy_buf_size; - - /* Number of characters read into yy_ch_buf, not including EOB - * characters. - */ - int yy_n_chars; - - /* Whether we "own" the buffer - i.e., we know we created it, - * and can realloc() it to grow it, and should free() it to - * delete it. - */ - int yy_is_our_buffer; - - /* Whether this is an "interactive" input source; if so, and - * if we're using stdio for input, then we want to use getc() - * instead of fread(), to make sure we stop fetching input after - * each newline. - */ - int yy_is_interactive; - - /* Whether we're considered to be at the beginning of a line. - * If so, '^' rules will be active on the next match, otherwise - * not. - */ - int yy_at_bol; - - int yy_bs_lineno; /**< The line count. */ - int yy_bs_column; /**< The column count. */ - - /* Whether to try to fill the input buffer when we reach the - * end of it. - */ - int yy_fill_buffer; - - int yy_buffer_status; - -#define YY_BUFFER_NEW 0 -#define YY_BUFFER_NORMAL 1 - /* When an EOF's been seen but there's still some text to process - * then we mark the buffer as YY_EOF_PENDING, to indicate that we - * shouldn't try reading from the input source any more. We might - * still have a bunch of tokens to match, though, because of - * possible backing-up. - * - * When we actually see the EOF, we change the status to "new" - * (via yyrestart()), so that the user can continue scanning by - * just pointing yyin at a new input file. - */ -#define YY_BUFFER_EOF_PENDING 2 - - }; -#endif /* !YY_STRUCT_YY_BUFFER_STATE */ - -/* Stack of input buffers. */ -static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ -static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ -static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ - -/* We provide macros for accessing buffer states in case in the - * future we want to put the buffer states in a more general - * "scanner state". - * - * Returns the top of the stack, or NULL. - */ -#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ - ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ - : NULL) -/* Same as previous macro, but useful when we know that the buffer stack is not - * NULL or when we need an lvalue. For internal use only. - */ -#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] - -/* yy_hold_char holds the character lost when yytext is formed. */ -static char yy_hold_char; -static int yy_n_chars; /* number of characters read into yy_ch_buf */ -int yyleng; - -/* Points to current character in buffer. */ -static char *yy_c_buf_p = NULL; -static int yy_init = 0; /* whether we need to initialize */ -static int yy_start = 0; /* start state number */ - -/* Flag which is used to allow yywrap()'s to do buffer switches - * instead of setting up a fresh yyin. A bit of a hack ... - */ -static int yy_did_buffer_switch_on_eof; - -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 ); -#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) - -YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); -YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); -YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); - -void *yyalloc ( yy_size_t ); -void *yyrealloc ( void *, yy_size_t ); -void yyfree ( void * ); - -#define yy_new_buffer yy_create_buffer -#define yy_set_interactive(is_interactive) \ - { \ - 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; \ - } -#define yy_set_bol(at_bol) \ - { \ - 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; \ - } -#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) - -/* Begin user sect3 */ - -#define yywrap() (/*CONSTCOND*/1) -#define YY_SKIP_YYWRAP -typedef flex_uint8_t YY_CHAR; - -FILE *yyin = NULL, *yyout = NULL; - -typedef int yy_state_type; - -extern int yylineno; -int yylineno = 1; - -extern char *yytext; -#ifdef yytext_ptr -#undef yytext_ptr -#endif -#define yytext_ptr yytext - -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 yynoreturn yy_fatal_error ( const char* msg ); - -/* Done after the current pattern has been matched and before the - * corresponding action - sets up yytext. - */ -#define YY_DO_BEFORE_ACTION \ - (yytext_ptr) = yy_bp; \ - yyleng = (int) (yy_cp - yy_bp); \ - (yy_hold_char) = *yy_cp; \ - *yy_cp = '\0'; \ - (yy_c_buf_p) = yy_cp; -#define YY_NUM_RULES 50 -#define YY_END_OF_BUFFER 51 -/* This struct is not used in this scanner, - but its presence is necessary. */ -struct yy_trans_info - { - flex_int32_t yy_verify; - flex_int32_t yy_nxt; - }; -static const flex_int16_t yy_accept[147] = - { 0, - 0, 0, 51, 49, 47, 46, 48, 24, 49, 20, - 25, 49, 36, 37, 18, 16, 30, 17, 27, 19, - 32, 29, 28, 21, 22, 45, 45, 38, 39, 45, - 45, 45, 45, 45, 45, 45, 45, 45, 40, 26, - 41, 0, 34, 0, 0, 0, 0, 31, 32, 23, - 45, 45, 45, 13, 45, 45, 45, 45, 45, 6, - 45, 45, 45, 45, 45, 45, 45, 33, 0, 0, - 0, 45, 45, 45, 45, 45, 45, 45, 45, 45, - 45, 45, 45, 45, 45, 45, 45, 0, 0, 0, - 35, 0, 45, 45, 45, 8, 45, 45, 45, 45, - - 44, 45, 45, 45, 7, 42, 9, 45, 0, 35, - 0, 0, 45, 45, 45, 45, 43, 45, 45, 45, - 45, 45, 5, 0, 45, 45, 45, 45, 45, 45, - 45, 45, 11, 3, 2, 45, 45, 45, 1, 14, - 15, 45, 12, 10, 4, 0 - } ; - -static const YY_CHAR yy_ec[256] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 4, 5, 6, 1, 1, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 18, 18, - 18, 18, 18, 18, 18, 18, 18, 19, 20, 21, - 22, 23, 1, 1, 24, 25, 24, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, - 26, 27, 28, 1, 24, 1, 29, 24, 30, 31, - - 32, 33, 34, 35, 36, 24, 24, 37, 24, 38, - 39, 40, 24, 41, 42, 43, 44, 45, 46, 47, - 48, 24, 49, 50, 51, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1 - } ; - -static const YY_CHAR yy_meta[52] = - { 0, - 1, 2, 3, 1, 1, 1, 1, 1, 2, 1, - 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, - 1, 1, 1, 4, 4, 1, 1, 1, 4, 4, - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, - 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, - 1 - } ; - -static const flex_int16_t yy_base[156] = - { 0, - 0, 0, 203, 204, 204, 204, 204, 204, 46, 204, - 204, 175, 189, 204, 204, 204, 204, 177, 204, 204, - 181, 176, 204, 204, 204, 0, 158, 204, 204, 22, - 161, 18, 25, 23, 151, 162, 22, 158, 204, 204, - 204, 52, 204, 53, 183, 51, 55, 204, 173, 204, - 0, 151, 158, 0, 159, 145, 143, 148, 146, 0, - 140, 145, 34, 149, 136, 139, 142, 204, 63, 165, - 69, 139, 134, 133, 141, 140, 129, 140, 137, 131, - 135, 134, 121, 126, 131, 130, 124, 71, 73, 75, - 204, 81, 128, 127, 129, 0, 116, 124, 112, 120, - - 0, 124, 111, 110, 0, 0, 0, 118, 86, 204, - 88, 90, 120, 106, 117, 108, 0, 109, 112, 101, - 97, 103, 0, 92, 102, 97, 95, 108, 72, 69, - 75, 63, 0, 0, 0, 58, 51, 34, 0, 0, - 0, 27, 0, 0, 0, 204, 104, 108, 58, 112, - 116, 120, 124, 128, 132 - } ; - -static const flex_int16_t yy_def[156] = - { 0, - 146, 1, 146, 146, 146, 146, 146, 146, 147, 146, - 146, 148, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 149, 149, 146, 146, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 146, 146, - 146, 147, 146, 146, 146, 146, 150, 146, 146, 146, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 146, 150, 151, - 152, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 150, 153, 154, - 146, 152, 149, 149, 149, 149, 149, 149, 149, 149, - - 149, 149, 149, 149, 149, 149, 149, 149, 155, 146, - 153, 154, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 155, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 0, 146, 146, 146, 146, - 146, 146, 146, 146, 146 - } ; - -static const flex_int16_t yy_nxt[256] = - { 0, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 4, 26, 27, 28, 4, 29, 30, 31, - 26, 32, 33, 26, 26, 34, 26, 35, 26, 26, - 36, 26, 37, 26, 26, 38, 26, 26, 39, 40, - 41, 43, 53, 58, 56, 60, 64, 43, 42, 45, - 61, 51, 65, 54, 57, 70, 71, 145, 59, 66, - 81, 144, 44, 88, 71, 82, 83, 45, 44, 91, - 92, 88, 71, 110, 111, 88, 71, 143, 45, 142, - 42, 110, 92, 45, 141, 42, 70, 89, 146, 111, - - 88, 71, 70, 89, 42, 42, 140, 42, 45, 139, - 138, 45, 69, 69, 69, 69, 70, 70, 70, 70, - 90, 90, 90, 90, 109, 109, 109, 109, 112, 112, - 112, 112, 124, 124, 124, 124, 137, 136, 135, 134, - 133, 132, 131, 130, 129, 128, 127, 126, 125, 123, - 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, - 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, - 98, 97, 96, 95, 94, 93, 89, 87, 86, 85, - 84, 80, 79, 78, 77, 76, 75, 74, 73, 72, - 49, 68, 67, 63, 62, 55, 52, 50, 49, 48, - - 47, 46, 146, 3, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146 - } ; - -static const flex_int16_t yy_chk[256] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 9, 30, 33, 32, 34, 37, 42, 44, 46, - 34, 149, 37, 30, 32, 47, 47, 142, 33, 37, - 63, 138, 9, 69, 69, 63, 63, 46, 42, 71, - 71, 88, 88, 89, 89, 90, 90, 137, 46, 136, - 44, 92, 92, 46, 132, 44, 109, 109, 111, 111, - - 112, 112, 124, 124, 147, 147, 131, 147, 148, 130, - 129, 148, 150, 150, 150, 150, 151, 151, 151, 151, - 152, 152, 152, 152, 153, 153, 153, 153, 154, 154, - 154, 154, 155, 155, 155, 155, 128, 127, 126, 125, - 122, 121, 120, 119, 118, 116, 115, 114, 113, 108, - 104, 103, 102, 100, 99, 98, 97, 95, 94, 93, - 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, - 77, 76, 75, 74, 73, 72, 70, 67, 66, 65, - 64, 62, 61, 59, 58, 57, 56, 55, 53, 52, - 49, 45, 38, 36, 35, 31, 27, 22, 21, 18, - - 13, 12, 3, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146 - } ; - -static yy_state_type yy_last_accepting_state; -static char *yy_last_accepting_cpos; - -extern int yy_flex_debug; -int yy_flex_debug = 0; - -/* The intent behind this definition is that it'll catch - * any uses of REJECT which flex missed. - */ -#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 -char *yytext; -#line 1 "lexicalStructure.lex" -/* Lexical Analysis with Flex (1.6.0) We used some of the code from this manual */ -/* so we placed the citation here. */ -/* definitions */ -#line 8 "lexicalStructure.lex" - #include - #include "typedefs.h" - int line_number = 1, column_number = 1; - #ifndef DEBUG - #define DEBUG 0 - #endif -#line 560 "lex.yy.c" -#line 22 "lexicalStructure.lex" - /* char can be a newline, tab, an escaped quote, or anything but a single quote, an actual line break, an actual tab, or a backslash by itself (to prevent confusion from escaped quote */ - /* similar to above, a string Char (SCHAR) is the same as a CHAR except we cannot have double quotes instead of single quotes. Double quotes need to be escaped in Flex unlike single quotes based on documentation */ -#line 564 "lex.yy.c" - -#define INITIAL 0 - -#ifndef YY_NO_UNISTD_H -/* Special case for "unistd.h", since it is non-ANSI. We include it way - * down here because we want the user's section 1 to have been scanned first. - * The user has a chance to override it with an option. - */ -#include -#endif - -#ifndef YY_EXTRA_TYPE -#define YY_EXTRA_TYPE void * -#endif - -static int yy_init_globals ( void ); - -/* Accessor methods to globals. - These are made visible to non-reentrant scanners for convenience. */ - -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 ); - -/* Macros after this point can all be overridden by user definitions in - * section 1. - */ - -#ifndef YY_SKIP_YYWRAP -#ifdef __cplusplus -extern "C" int yywrap ( void ); -#else -extern int yywrap ( void ); -#endif -#endif - -#ifndef YY_NO_UNPUT - - static void yyunput ( int c, char *buf_ptr ); - -#endif - -#ifndef yytext_ptr -static void yy_flex_strncpy ( char *, const char *, int ); -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen ( const char * ); -#endif - -#ifndef YY_NO_INPUT -#ifdef __cplusplus -static int yyinput ( void ); -#else -static int input ( void ); -#endif - -#endif - -/* Amount of stuff to slurp up with each read. */ -#ifndef YY_READ_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k */ -#define YY_READ_BUF_SIZE 16384 -#else -#define YY_READ_BUF_SIZE 8192 -#endif /* __ia64__ */ -#endif - -/* Copy whatever the last rule matched to the standard output. */ -#ifndef ECHO -/* This used to be an fputs(), but since the string might contain NUL's, - * we now use fwrite(). - */ -#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) -#endif - -/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, - * is returned in "result". - */ -#ifndef YY_INPUT -#define YY_INPUT(buf,result,max_size) \ - if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ - { \ - int c = '*'; \ - int n; \ - for ( n = 0; n < max_size && \ - (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ - buf[n] = (char) c; \ - if ( c == '\n' ) \ - buf[n++] = (char) c; \ - if ( c == EOF && ferror( yyin ) ) \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - result = n; \ - } \ - else \ - { \ - errno=0; \ - while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ - { \ - if( errno != EINTR) \ - { \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - break; \ - } \ - errno=0; \ - clearerr(yyin); \ - } \ - }\ -\ - -#endif - -/* No semi-colon after return; correct usage is to write "yyterminate();" - - * we don't want an extra ';' after the "return" because that will cause - * some compilers to complain about unreachable statements. - */ -#ifndef yyterminate -#define yyterminate() return YY_NULL -#endif - -/* Number of entries by which start-condition stack grows. */ -#ifndef YY_START_STACK_INCR -#define YY_START_STACK_INCR 25 -#endif - -/* Report a fatal error. */ -#ifndef YY_FATAL_ERROR -#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) -#endif - -/* end tables serialization structures and prototypes */ - -/* Default declaration of generated scanner - a define so the user can - * easily add parameters. - */ -#ifndef YY_DECL -#define YY_DECL_IS_OURS 1 - -extern int yylex (void); - -#define YY_DECL int yylex (void) -#endif /* !YY_DECL */ - -/* Code executed at the beginning of each rule, after yytext and yyleng - * have been set up. - */ -#ifndef YY_USER_ACTION -#define YY_USER_ACTION -#endif - -/* Code executed at the end of each rule. */ -#ifndef YY_BREAK -#define YY_BREAK /*LINTED*/break; -#endif - -#define YY_RULE_SETUP \ - YY_USER_ACTION - -/** The main scanner function which does all the work. - */ -YY_DECL -{ - yy_state_type yy_current_state; - char *yy_cp, *yy_bp; - int yy_act; - - if ( !(yy_init) ) - { - (yy_init) = 1; - -#ifdef YY_USER_INIT - YY_USER_INIT; -#endif - - if ( ! (yy_start) ) - (yy_start) = 1; /* first start state */ - - if ( ! yyin ) - yyin = stdin; - - if ( ! yyout ) - yyout = stdout; - - if ( ! YY_CURRENT_BUFFER ) { - yyensure_buffer_stack (); - YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer( yyin, YY_BUF_SIZE ); - } - - yy_load_buffer_state( ); - } - - { -#line 26 "lexicalStructure.lex" - - -#line 784 "lex.yy.c" - - while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ - { - yy_cp = (yy_c_buf_p); - - /* Support of yytext. */ - *yy_cp = (yy_hold_char); - - /* yy_bp points to the position in yy_ch_buf of the start of - * the current run. - */ - yy_bp = yy_cp; - - yy_current_state = (yy_start); -yy_match: - do - { - YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 147 ) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - ++yy_cp; - } - while ( yy_base[yy_current_state] != 204 ); - -yy_find_action: - yy_act = yy_accept[yy_current_state]; - if ( yy_act == 0 ) - { /* have to back up */ - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - yy_act = yy_accept[yy_current_state]; - } - - YY_DO_BEFORE_ACTION; - -do_action: /* This label is used only to access EOF actions. */ - - switch ( yy_act ) - { /* beginning of action switch */ - case 0: /* must back up */ - /* undo the effects of YY_DO_BEFORE_ACTION */ - *yy_cp = (yy_hold_char); - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - goto yy_find_action; - -case 1: -YY_RULE_SETUP -#line 28 "lexicalStructure.lex" -{if(DEBUG) {printf( "T_INTEGER: %s (%d)\n", yytext, T_INTEGER);} else {return T_INTEGER;}} - YY_BREAK -case 2: -YY_RULE_SETUP -#line 29 "lexicalStructure.lex" -{if(DEBUG) {printf( "T_ADDRESS: %s (%d)\n", yytext, T_ADDRESS);} else {return T_ADDRESS;}} - YY_BREAK -case 3: -YY_RULE_SETUP -#line 30 "lexicalStructure.lex" -{if(DEBUG) {printf( "T_BOOLEAN: %s (%d)\n", yytext, T_BOOLEAN);} else {return T_BOOLEAN;}} - YY_BREAK -case 4: -YY_RULE_SETUP -#line 31 "lexicalStructure.lex" -{if(DEBUG) {printf( "T_CHARACTER: %s (%d)\n", yytext, T_CHARACTER);} else {return T_CHARACTER;}} - YY_BREAK -case 5: -YY_RULE_SETUP -#line 33 "lexicalStructure.lex" -{if(DEBUG) {printf( "WHILE: %s (%d)\n", yytext, WHILE);} else {return WHILE;}} - YY_BREAK -case 6: -YY_RULE_SETUP -#line 34 "lexicalStructure.lex" -{if(DEBUG) {printf( "IF: %s (%d)\n", yytext, IF);} else {return IF;}} - YY_BREAK -case 7: -YY_RULE_SETUP -#line 35 "lexicalStructure.lex" -{if(DEBUG) {printf( "THEN: %s (%d)\n", yytext, THEN);} else {return THEN;}} - YY_BREAK -case 8: -YY_RULE_SETUP -#line 36 "lexicalStructure.lex" -{if(DEBUG) {printf( "ELSE: %s (%d)\n", yytext, ELSE);} else {return ELSE;}} - YY_BREAK -case 9: -YY_RULE_SETUP -#line 37 "lexicalStructure.lex" -{if(DEBUG) {printf( "TYPE: %s (%d)\n", yytext, TYPE);} else {return TYPE;}} - YY_BREAK -case 10: -YY_RULE_SETUP -#line 38 "lexicalStructure.lex" -{if(DEBUG) {printf( "FUNCTION: %s (%d)\n", yytext, FUNCTION);} else {return FUNCTION;}} - YY_BREAK -case 11: -YY_RULE_SETUP -#line 39 "lexicalStructure.lex" -{if(DEBUG) {printf( "RETURN: %s (%d)\n", yytext, RETURN);} else {return RETURN;}} - YY_BREAK -case 12: -YY_RULE_SETUP -#line 40 "lexicalStructure.lex" -{if(DEBUG) {printf( "EXTERNAL: %s (%d)\n", yytext, EXTERNAL);} else {return EXTERNAL;}} - YY_BREAK -case 13: -YY_RULE_SETUP -#line 41 "lexicalStructure.lex" -{if(DEBUG) {printf( "AS: %s (%d)\n", yytext, AS);} else {return AS;}} - YY_BREAK -case 14: -YY_RULE_SETUP -#line 43 "lexicalStructure.lex" -{if(DEBUG) {printf( "RELEASE: %s (%d)\n", yytext, RELEASE);} else {return RELEASE;}} - YY_BREAK -case 15: -YY_RULE_SETUP -#line 44 "lexicalStructure.lex" -{if(DEBUG) {printf( "RESERVE: %s (%d)\n", yytext, RESERVE);} else {return RESERVE;}} - YY_BREAK -case 16: -YY_RULE_SETUP -#line 46 "lexicalStructure.lex" -{if(DEBUG) {printf( "ADD: %s (%d)\n", yytext, ADD);} else {return ADD;}} - YY_BREAK -case 17: -YY_RULE_SETUP -#line 47 "lexicalStructure.lex" -{if(DEBUG) {printf( "SUB_OR_NEG: %s (%d)\n", yytext, SUB_OR_NEG);} else {return SUB_OR_NEG;}} - YY_BREAK -case 18: -YY_RULE_SETUP -#line 48 "lexicalStructure.lex" -{if(DEBUG) {printf( "MUL: %s (%d)\n", yytext, MUL);} else {return MUL;}} - YY_BREAK -case 19: -YY_RULE_SETUP -#line 49 "lexicalStructure.lex" -{if(DEBUG) {printf( "DIV: %s (%d)\n", yytext, DIV);} else {return DIV;}} - YY_BREAK -case 20: -YY_RULE_SETUP -#line 50 "lexicalStructure.lex" -{if(DEBUG) {printf( "REM: %s (%d)\n", yytext, REM);} else {return REM;}} - YY_BREAK -case 21: -YY_RULE_SETUP -#line 51 "lexicalStructure.lex" -{if(DEBUG) {printf( "LESS_THAN: %s (%d)\n", yytext, LESS_THAN);} else {return LESS_THAN;}} - YY_BREAK -case 22: -YY_RULE_SETUP -#line 52 "lexicalStructure.lex" -{if(DEBUG) {printf( "EQUAL_TO: %s (%d)\n", yytext, EQUAL_TO);} else {return EQUAL_TO;}} - YY_BREAK -case 23: -YY_RULE_SETUP -#line 53 "lexicalStructure.lex" -{if(DEBUG) {printf( "ASSIGN: %s (%d)\n", yytext, ASSIGN);} else {return ASSIGN;}} - YY_BREAK -case 24: -YY_RULE_SETUP -#line 54 "lexicalStructure.lex" -{if(DEBUG) {printf( "NOT: %s (%d)\n", yytext, NOT);} else {return NOT;}} - YY_BREAK -case 25: -YY_RULE_SETUP -#line 55 "lexicalStructure.lex" -{if(DEBUG) {printf( "AND: %s (%d)\n", yytext, AND);} else {return AND;}} - YY_BREAK -case 26: -YY_RULE_SETUP -#line 56 "lexicalStructure.lex" -{if(DEBUG) {printf( "OR: %s (%d)\n", yytext, OR);} else {return OR;}} - YY_BREAK -case 27: -YY_RULE_SETUP -#line 57 "lexicalStructure.lex" -{if(DEBUG) {printf( "DOT: %s (%d)\n", yytext, DOT);} else {return DOT;}} - YY_BREAK -case 28: -YY_RULE_SETUP -#line 59 "lexicalStructure.lex" -{if(DEBUG) {printf( "SEMI_COLON: %s (%d)\n", yytext, SEMI_COLON);} else {return SEMI_COLON;}} - YY_BREAK -case 29: -YY_RULE_SETUP -#line 60 "lexicalStructure.lex" -{if(DEBUG) {printf( "COLON: %s (%d)\n", yytext, COLON);} else {return COLON;}} - YY_BREAK -case 30: -YY_RULE_SETUP -#line 61 "lexicalStructure.lex" -{if(DEBUG) {printf( "COMMA: %s (%d)\n", yytext, COMMA);} else {return COMMA;}} - YY_BREAK -case 31: -YY_RULE_SETUP -#line 62 "lexicalStructure.lex" -{if(DEBUG) {printf( "ARROW: %s (%d)\n", yytext, ARROW);} else {return ARROW;}} - YY_BREAK -case 32: -YY_RULE_SETUP -#line 64 "lexicalStructure.lex" -{if(DEBUG) {printf( "C_INTEGER: %s (%d)\n", yytext, C_INTEGER);} else {return C_INTEGER;}} - YY_BREAK -case 33: -YY_RULE_SETUP -#line 65 "lexicalStructure.lex" -{if(DEBUG) {printf( "C_CHARACTER: %s (%d)\n", yytext, C_CHARACTER);} else {return C_CHARACTER;}} - YY_BREAK -case 34: -YY_RULE_SETUP -#line 66 "lexicalStructure.lex" -{if(DEBUG) {printf( "C_STRING: %s (%d)\n", yytext, C_STRING);} else {return C_STRING;}} - YY_BREAK -case 35: -/* rule 35 can match eol */ -YY_RULE_SETUP -#line 67 "lexicalStructure.lex" -{if(DEBUG) {printf( "COMMENT: %s (%d)\n", yytext, COMMENT);} else {return COMMENT;}} - YY_BREAK -case 36: -YY_RULE_SETUP -#line 69 "lexicalStructure.lex" -{if(DEBUG) {printf( "L_PAREN: %s (%d)\n", yytext, L_PAREN);} else {return L_PAREN;}} - YY_BREAK -case 37: -YY_RULE_SETUP -#line 70 "lexicalStructure.lex" -{if(DEBUG) {printf( "R_PAREN: %s (%d)\n", yytext, R_PAREN);} else {return R_PAREN;}} - YY_BREAK -case 38: -YY_RULE_SETUP -#line 72 "lexicalStructure.lex" -{if(DEBUG) {printf( "L_BRACKET: %s (%d)\n", yytext, L_BRACKET);} else {return L_BRACKET;}} - YY_BREAK -case 39: -YY_RULE_SETUP -#line 73 "lexicalStructure.lex" -{if(DEBUG) {printf( "R_BRACKET: %s (%d)\n", yytext, R_BRACKET);} else {return R_BRACKET;}} - YY_BREAK -case 40: -YY_RULE_SETUP -#line 75 "lexicalStructure.lex" -{if(DEBUG) {printf( "L_BRACE: %s (%d)\n", yytext, L_BRACE);} else {return L_BRACE;}} - YY_BREAK -case 41: -YY_RULE_SETUP -#line 76 "lexicalStructure.lex" -{if(DEBUG) {printf( "R_BRACE: %s (%d)\n", yytext, R_BRACE);} else {return R_BRACE;}} - YY_BREAK -case 42: -YY_RULE_SETUP -#line 78 "lexicalStructure.lex" -{if(DEBUG) {printf( "C_TRUE: %s (%d)\n", yytext, C_TRUE);} else {return C_TRUE;}} - YY_BREAK -case 43: -YY_RULE_SETUP -#line 79 "lexicalStructure.lex" -{if(DEBUG) {printf( "C_FALSE: %s (%d)\n", yytext, C_FALSE);} else {return C_FALSE;}} - YY_BREAK -case 44: -YY_RULE_SETUP -#line 80 "lexicalStructure.lex" -{if(DEBUG) {printf( "C_NULL: %s (%d)\n", yytext, C_NULL);} else {return C_NULL;}} - YY_BREAK -case 45: -YY_RULE_SETUP -#line 82 "lexicalStructure.lex" -{if(DEBUG) {printf( "ID: %s (%d)\n", yytext, ID);} else {return ID;}} - YY_BREAK -case 46: -/* rule 46 can match eol */ -YY_RULE_SETUP -#line 84 "lexicalStructure.lex" -{line_number++; column_number = 1;} - YY_BREAK -case 47: -YY_RULE_SETUP -#line 85 "lexicalStructure.lex" -{column_number++;} - YY_BREAK -case 48: -YY_RULE_SETUP -#line 86 "lexicalStructure.lex" -{column_number++;} - YY_BREAK -case 49: -YY_RULE_SETUP -#line 87 "lexicalStructure.lex" -{column_number++; return 1999;} - YY_BREAK -case 50: -YY_RULE_SETUP -#line 89 "lexicalStructure.lex" -ECHO; - YY_BREAK -#line 1093 "lex.yy.c" -case YY_STATE_EOF(INITIAL): - yyterminate(); - - case YY_END_OF_BUFFER: - { - /* Amount of text matched not including the EOB char. */ - int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; - - /* Undo the effects of YY_DO_BEFORE_ACTION. */ - *yy_cp = (yy_hold_char); - YY_RESTORE_YY_MORE_OFFSET - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) - { - /* We're scanning a new file or input source. It's - * possible that this happened because the user - * just pointed yyin at a new source and called - * yylex(). If so, then we have to assure - * consistency between YY_CURRENT_BUFFER and our - * globals. Here is the right place to do so, because - * this is the first action (other than possibly a - * back-up) that will match for the new input source. - */ - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; - } - - /* Note that here we test for yy_c_buf_p "<=" to the position - * of the first EOB in the buffer, since yy_c_buf_p will - * already have been incremented past the NUL character - * (since all states make transitions on EOB to the - * end-of-buffer state). Contrast this with the test - * in input(). - */ - if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) - { /* This was really a NUL. */ - yy_state_type yy_next_state; - - (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( ); - - /* Okay, we're now positioned to make the NUL - * transition. We couldn't have - * yy_get_previous_state() go ahead and do it - * for us because it doesn't know how to deal - * with the possibility of jamming (and we don't - * want to build jamming into it because then it - * will run more slowly). - */ - - yy_next_state = yy_try_NUL_trans( yy_current_state ); - - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - - if ( yy_next_state ) - { - /* Consume the NUL. */ - yy_cp = ++(yy_c_buf_p); - yy_current_state = yy_next_state; - goto yy_match; - } - - else - { - yy_cp = (yy_c_buf_p); - goto yy_find_action; - } - } - - else switch ( yy_get_next_buffer( ) ) - { - case EOB_ACT_END_OF_FILE: - { - (yy_did_buffer_switch_on_eof) = 0; - - if ( yywrap( ) ) - { - /* Note: because we've taken care in - * yy_get_next_buffer() to have set up - * yytext, we can now set up - * yy_c_buf_p so that if some total - * hoser (like flex itself) wants to - * call the scanner after we return the - * YY_NULL, it'll still work - another - * YY_NULL will get returned. - */ - (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; - - yy_act = YY_STATE_EOF(YY_START); - goto do_action; - } - - else - { - if ( ! (yy_did_buffer_switch_on_eof) ) - YY_NEW_FILE; - } - break; - } - - case EOB_ACT_CONTINUE_SCAN: - (yy_c_buf_p) = - (yytext_ptr) + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( ); - - yy_cp = (yy_c_buf_p); - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - goto yy_match; - - case EOB_ACT_LAST_MATCH: - (yy_c_buf_p) = - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; - - yy_current_state = yy_get_previous_state( ); - - yy_cp = (yy_c_buf_p); - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - goto yy_find_action; - } - break; - } - - default: - YY_FATAL_ERROR( - "fatal flex scanner internal error--no action found" ); - } /* end of action switch */ - } /* end of scanning one token */ - } /* end of user's declarations */ -} /* end of yylex */ - -/* yy_get_next_buffer - try to read in a new buffer - * - * Returns a code representing an action: - * EOB_ACT_LAST_MATCH - - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position - * EOB_ACT_END_OF_FILE - end of file - */ -static int yy_get_next_buffer (void) -{ - char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - char *source = (yytext_ptr); - int number_to_move, i; - int ret_val; - - if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) - YY_FATAL_ERROR( - "fatal flex scanner internal error--end of buffer missed" ); - - if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) - { /* Don't try to fill the buffer, so this is an EOF. */ - if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) - { - /* We matched a single character, the EOB, so - * treat this as a final EOF. - */ - return EOB_ACT_END_OF_FILE; - } - - else - { - /* We matched some text prior to the EOB, first - * process it. - */ - return EOB_ACT_LAST_MATCH; - } - } - - /* Try to read more data. */ - - /* First move last chars to start of buffer. */ - number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); - - for ( i = 0; i < number_to_move; ++i ) - *(dest++) = *(source++); - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) - /* don't do the read, it's not guaranteed to return an EOF, - * just force an EOF - */ - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; - - else - { - int num_to_read = - YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; - - while ( num_to_read <= 0 ) - { /* Not enough room in the buffer - grow it. */ - - /* just a shorter name for the current buffer */ - YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; - - int yy_c_buf_p_offset = - (int) ((yy_c_buf_p) - b->yy_ch_buf); - - if ( b->yy_is_our_buffer ) - { - int new_size = b->yy_buf_size * 2; - - if ( new_size <= 0 ) - b->yy_buf_size += b->yy_buf_size / 8; - else - b->yy_buf_size *= 2; - - b->yy_ch_buf = (char *) - /* Include room in for 2 EOB chars. */ - yyrealloc( (void *) b->yy_ch_buf, - (yy_size_t) (b->yy_buf_size + 2) ); - } - else - /* Can't grow it, we don't own it. */ - b->yy_ch_buf = NULL; - - if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( - "fatal error - scanner input buffer overflow" ); - - (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; - - num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - - number_to_move - 1; - - } - - if ( num_to_read > YY_READ_BUF_SIZE ) - num_to_read = YY_READ_BUF_SIZE; - - /* Read in more data. */ - YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), - (yy_n_chars), num_to_read ); - - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - if ( (yy_n_chars) == 0 ) - { - if ( number_to_move == YY_MORE_ADJ ) - { - ret_val = EOB_ACT_END_OF_FILE; - yyrestart( yyin ); - } - - else - { - ret_val = EOB_ACT_LAST_MATCH; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = - YY_BUFFER_EOF_PENDING; - } - } - - else - ret_val = EOB_ACT_CONTINUE_SCAN; - - if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { - /* Extend the array by 50%, plus the number we really need. */ - int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( - (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); - if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); - /* "- 2" to take care of EOB's */ - YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); - } - - (yy_n_chars) += number_to_move; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; - - (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; - - return ret_val; -} - -/* yy_get_previous_state - get the state just before the EOB char was reached */ - - static yy_state_type yy_get_previous_state (void) -{ - yy_state_type yy_current_state; - char *yy_cp; - - yy_current_state = (yy_start); - - for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) - { - YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 147 ) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - } - - return yy_current_state; -} - -/* yy_try_NUL_trans - try to make a transition on the NUL character - * - * synopsis - * next_state = yy_try_NUL_trans( current_state ); - */ - static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) -{ - int yy_is_jam; - char *yy_cp = (yy_c_buf_p); - - YY_CHAR yy_c = 1; - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 147 ) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 146); - - return yy_is_jam ? 0 : yy_current_state; -} - -#ifndef YY_NO_UNPUT - - static void yyunput (int c, char * yy_bp ) -{ - char *yy_cp; - - yy_cp = (yy_c_buf_p); - - /* undo effects of setting up yytext */ - *yy_cp = (yy_hold_char); - - if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) - { /* need to shift things up to make room */ - /* +2 for EOB chars. */ - int number_to_move = (yy_n_chars) + 2; - char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ - YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; - char *source = - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; - - while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) - *--dest = *--source; - - yy_cp += (int) (dest - source); - yy_bp += (int) (dest - source); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = - (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; - - if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) - YY_FATAL_ERROR( "flex scanner push-back overflow" ); - } - - *--yy_cp = (char) c; - - (yytext_ptr) = yy_bp; - (yy_hold_char) = *yy_cp; - (yy_c_buf_p) = yy_cp; -} - -#endif - -#ifndef YY_NO_INPUT -#ifdef __cplusplus - static int yyinput (void) -#else - static int input (void) -#endif - -{ - int c; - - *(yy_c_buf_p) = (yy_hold_char); - - if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) - { - /* yy_c_buf_p now points to the character we want to return. - * If this occurs *before* the EOB characters, then it's a - * valid NUL; if not, then we've hit the end of the buffer. - */ - if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) - /* This was really a NUL. */ - *(yy_c_buf_p) = '\0'; - - else - { /* need more input */ - int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); - ++(yy_c_buf_p); - - switch ( yy_get_next_buffer( ) ) - { - case EOB_ACT_LAST_MATCH: - /* This happens because yy_g_n_b() - * sees that we've accumulated a - * token and flags that we need to - * try matching the token before - * proceeding. But for input(), - * there's no matching to consider. - * So convert the EOB_ACT_LAST_MATCH - * to EOB_ACT_END_OF_FILE. - */ - - /* Reset buffer status. */ - yyrestart( yyin ); - - /*FALLTHROUGH*/ - - case EOB_ACT_END_OF_FILE: - { - if ( yywrap( ) ) - return 0; - - if ( ! (yy_did_buffer_switch_on_eof) ) - YY_NEW_FILE; -#ifdef __cplusplus - return yyinput(); -#else - return input(); -#endif - } - - case EOB_ACT_CONTINUE_SCAN: - (yy_c_buf_p) = (yytext_ptr) + offset; - break; - } - } - } - - c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ - *(yy_c_buf_p) = '\0'; /* preserve yytext */ - (yy_hold_char) = *++(yy_c_buf_p); - - return c; -} -#endif /* ifndef YY_NO_INPUT */ - -/** Immediately switch to a different input stream. - * @param input_file A readable stream. - * - * @note This function does not reset the start condition to @c INITIAL . - */ - void yyrestart (FILE * input_file ) -{ - - if ( ! YY_CURRENT_BUFFER ){ - yyensure_buffer_stack (); - YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer( yyin, YY_BUF_SIZE ); - } - - yy_init_buffer( YY_CURRENT_BUFFER, input_file ); - yy_load_buffer_state( ); -} - -/** Switch to a different input buffer. - * @param new_buffer The new input buffer. - * - */ - void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) -{ - - /* TODO. We should be able to replace this entire function body - * with - * yypop_buffer_state(); - * yypush_buffer_state(new_buffer); - */ - yyensure_buffer_stack (); - if ( YY_CURRENT_BUFFER == new_buffer ) - return; - - if ( YY_CURRENT_BUFFER ) - { - /* Flush out information for old buffer. */ - *(yy_c_buf_p) = (yy_hold_char); - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - YY_CURRENT_BUFFER_LVALUE = new_buffer; - yy_load_buffer_state( ); - - /* We don't actually know whether we did this switch during - * EOF (yywrap()) processing, but the only time this flag - * is looked at is after yywrap() is called, so it's safe - * to go ahead and always set it. - */ - (yy_did_buffer_switch_on_eof) = 1; -} - -static void yy_load_buffer_state (void) -{ - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; - yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; - (yy_hold_char) = *(yy_c_buf_p); -} - -/** Allocate and initialize an input buffer state. - * @param file A readable stream. - * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. - * - * @return the allocated buffer state. - */ - YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) -{ - YY_BUFFER_STATE b; - - b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); - if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); - - b->yy_buf_size = size; - - /* yy_ch_buf has to be 2 characters longer than the size given because - * we need to put in 2 end-of-buffer characters. - */ - b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); - if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); - - b->yy_is_our_buffer = 1; - - yy_init_buffer( b, file ); - - return b; -} - -/** Destroy the buffer. - * @param b a buffer created with yy_create_buffer() - * - */ - void yy_delete_buffer (YY_BUFFER_STATE b ) -{ - - if ( ! b ) - return; - - if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ - YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; - - if ( b->yy_is_our_buffer ) - yyfree( (void *) b->yy_ch_buf ); - - yyfree( (void *) b ); -} - -/* Initializes or reinitializes a buffer. - * This function is sometimes called more than once on the same buffer, - * such as during a yyrestart() or at EOF. - */ - static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) - -{ - int oerrno = errno; - - yy_flush_buffer( b ); - - b->yy_input_file = file; - b->yy_fill_buffer = 1; - - /* If b is the current buffer, then yy_init_buffer was _probably_ - * called from yyrestart() or through yy_get_next_buffer. - * In that case, we don't want to reset the lineno or column. - */ - if (b != YY_CURRENT_BUFFER){ - b->yy_bs_lineno = 1; - b->yy_bs_column = 0; - } - - b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; - - errno = oerrno; -} - -/** Discard all buffered characters. On the next scan, YY_INPUT will be called. - * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. - * - */ - void yy_flush_buffer (YY_BUFFER_STATE b ) -{ - if ( ! b ) - return; - - b->yy_n_chars = 0; - - /* We always need two end-of-buffer characters. The first causes - * a transition to the end-of-buffer state. The second causes - * a jam in that state. - */ - b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; - b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; - - b->yy_buf_pos = &b->yy_ch_buf[0]; - - b->yy_at_bol = 1; - b->yy_buffer_status = YY_BUFFER_NEW; - - if ( b == YY_CURRENT_BUFFER ) - yy_load_buffer_state( ); -} - -/** Pushes the new state onto the stack. The new state becomes - * the current state. This function will allocate the stack - * if necessary. - * @param new_buffer The new state. - * - */ -void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) -{ - if (new_buffer == NULL) - return; - - yyensure_buffer_stack(); - - /* This block is copied from yy_switch_to_buffer. */ - if ( YY_CURRENT_BUFFER ) - { - /* Flush out information for old buffer. */ - *(yy_c_buf_p) = (yy_hold_char); - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - /* Only push if top exists. Otherwise, replace top. */ - if (YY_CURRENT_BUFFER) - (yy_buffer_stack_top)++; - YY_CURRENT_BUFFER_LVALUE = new_buffer; - - /* copied from yy_switch_to_buffer. */ - yy_load_buffer_state( ); - (yy_did_buffer_switch_on_eof) = 1; -} - -/** Removes and deletes the top of the stack, if present. - * The next element becomes the new top. - * - */ -void yypop_buffer_state (void) -{ - if (!YY_CURRENT_BUFFER) - return; - - yy_delete_buffer(YY_CURRENT_BUFFER ); - YY_CURRENT_BUFFER_LVALUE = NULL; - if ((yy_buffer_stack_top) > 0) - --(yy_buffer_stack_top); - - if (YY_CURRENT_BUFFER) { - yy_load_buffer_state( ); - (yy_did_buffer_switch_on_eof) = 1; - } -} - -/* Allocates the stack if it does not exist. - * Guarantees space for at least one push. - */ -static void yyensure_buffer_stack (void) -{ - yy_size_t num_to_alloc; - - if (!(yy_buffer_stack)) { - - /* First allocation is just for 2 elements, since we don't know if this - * scanner will even need a stack. We use 2 instead of 1 to avoid an - * immediate realloc on the next call. - */ - num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ - (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc - (num_to_alloc * sizeof(struct yy_buffer_state*) - ); - if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - - memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); - - (yy_buffer_stack_max) = num_to_alloc; - (yy_buffer_stack_top) = 0; - return; - } - - if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ - - /* Increase the buffer to prepare for a possible push. */ - yy_size_t grow_size = 8 /* arbitrary grow size */; - - num_to_alloc = (yy_buffer_stack_max) + grow_size; - (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc - ((yy_buffer_stack), - num_to_alloc * sizeof(struct yy_buffer_state*) - ); - if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - - /* zero only the new slots.*/ - memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); - (yy_buffer_stack_max) = num_to_alloc; - } -} - -/** Setup the input buffer state to scan directly from a user-specified character buffer. - * @param base the character buffer - * @param size the size in bytes of the character buffer - * - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) -{ - YY_BUFFER_STATE b; - - if ( size < 2 || - base[size-2] != YY_END_OF_BUFFER_CHAR || - base[size-1] != YY_END_OF_BUFFER_CHAR ) - /* They forgot to leave room for the EOB's. */ - return NULL; - - b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); - if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); - - b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ - b->yy_buf_pos = b->yy_ch_buf = base; - b->yy_is_our_buffer = 0; - b->yy_input_file = NULL; - b->yy_n_chars = b->yy_buf_size; - b->yy_is_interactive = 0; - b->yy_at_bol = 1; - b->yy_fill_buffer = 0; - b->yy_buffer_status = YY_BUFFER_NEW; - - yy_switch_to_buffer( b ); - - return b; -} - -/** Setup the input buffer state to scan a string. The next call to yylex() will - * scan from a @e copy of @a str. - * @param yystr a NUL-terminated string to scan - * - * @return the newly allocated buffer state object. - * @note If you want to scan bytes that may contain NUL values, then use - * yy_scan_bytes() instead. - */ -YY_BUFFER_STATE yy_scan_string (const char * yystr ) -{ - - return yy_scan_bytes( yystr, (int) strlen(yystr) ); -} - -/** Setup the input buffer state to scan the given bytes. The next call to yylex() will - * scan from a @e copy of @a bytes. - * @param yybytes the byte buffer to scan - * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. - * - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) -{ - YY_BUFFER_STATE b; - char *buf; - yy_size_t n; - int i; - - /* Get memory for full buffer, including space for trailing EOB's. */ - n = (yy_size_t) (_yybytes_len + 2); - buf = (char *) yyalloc( n ); - if ( ! buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); - - for ( i = 0; i < _yybytes_len; ++i ) - buf[i] = yybytes[i]; - - buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - - b = yy_scan_buffer( buf, n ); - if ( ! b ) - YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); - - /* It's okay to grow etc. this buffer, and we should throw it - * away when we're done. - */ - b->yy_is_our_buffer = 1; - - return b; -} - -#ifndef YY_EXIT_FAILURE -#define YY_EXIT_FAILURE 2 -#endif - -static void yynoreturn yy_fatal_error (const char* msg ) -{ - fprintf( stderr, "%s\n", msg ); - exit( YY_EXIT_FAILURE ); -} - -/* Redefine yyless() so it works in section 3 code. */ - -#undef yyless -#define yyless(n) \ - 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 ) - -/* Accessor methods (get/set functions) to struct members. */ - -/** Get the current line number. - * - */ -int yyget_lineno (void) -{ - - return yylineno; -} - -/** Get the input stream. - * - */ -FILE *yyget_in (void) -{ - return yyin; -} - -/** Get the output stream. - * - */ -FILE *yyget_out (void) -{ - return yyout; -} - -/** Get the length of the current token. - * - */ -int yyget_leng (void) -{ - return yyleng; -} - -/** Get the current token. - * - */ - -char *yyget_text (void) -{ - return yytext; -} - -/** Set the current line number. - * @param _line_number line number - * - */ -void yyset_lineno (int _line_number ) -{ - - yylineno = _line_number; -} - -/** Set the input stream. This does not discard the current - * input buffer. - * @param _in_str A readable stream. - * - * @see yy_switch_to_buffer - */ -void yyset_in (FILE * _in_str ) -{ - yyin = _in_str ; -} - -void yyset_out (FILE * _out_str ) -{ - yyout = _out_str ; -} - -int yyget_debug (void) -{ - return yy_flex_debug; -} - -void yyset_debug (int _bdebug ) -{ - yy_flex_debug = _bdebug ; -} - -static int yy_init_globals (void) -{ - /* Initialization is the same as for the non-reentrant scanner. - * This function is called from yylex_destroy(), so don't allocate here. - */ - - (yy_buffer_stack) = NULL; - (yy_buffer_stack_top) = 0; - (yy_buffer_stack_max) = 0; - (yy_c_buf_p) = NULL; - (yy_init) = 0; - (yy_start) = 0; - -/* Defined in main.c */ -#ifdef YY_STDINIT - yyin = stdin; - yyout = stdout; -#else - yyin = NULL; - yyout = NULL; -#endif - - /* For future reference: Set errno on error, since we are called by - * yylex_init() - */ - return 0; -} - -/* yylex_destroy is for both reentrant and non-reentrant scanners. */ -int yylex_destroy (void) -{ - - /* Pop the buffer stack, destroying each element. */ - while(YY_CURRENT_BUFFER){ - yy_delete_buffer( YY_CURRENT_BUFFER ); - YY_CURRENT_BUFFER_LVALUE = NULL; - yypop_buffer_state(); - } - - /* Destroy the stack itself. */ - yyfree((yy_buffer_stack) ); - (yy_buffer_stack) = NULL; - - /* Reset the globals. This is important in a non-reentrant scanner so the next time - * yylex() is called, initialization will occur. */ - yy_init_globals( ); - - return 0; -} - -/* - * Internal utility routines. - */ - -#ifndef yytext_ptr -static void yy_flex_strncpy (char* s1, const char * s2, int n ) -{ - - int i; - for ( i = 0; i < n; ++i ) - s1[i] = s2[i]; -} -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen (const char * s ) -{ - int n; - for ( n = 0; s[n]; ++n ) - ; - - return n; -} -#endif - -void *yyalloc (yy_size_t size ) -{ - return malloc(size); -} - -void *yyrealloc (void * ptr, yy_size_t size ) -{ - - /* The cast to (char *) in the following accommodates both - * implementations that use char* generic pointers, and those - * that use void* generic pointers. It works with the latter - * because both ANSI C and C++ allow castless assignment from - * any pointer type to void*, and deal with argument conversions - * as though doing an assignment. - */ - return realloc(ptr, size); -} - -void yyfree (void * ptr ) -{ - free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ -} - -#define YYTABLES_NAME "yytables" - -#line 89 "lexicalStructure.lex" - - diff --git a/lexicalStructure.lex b/lexicalStructure.lex index 64b2863..f4fb603 100644 --- a/lexicalStructure.lex +++ b/lexicalStructure.lex @@ -7,6 +7,7 @@ %{ #include #include "typedefs.h" + #include "grammar.tab.h" int line_number = 1, column_number = 1; #ifndef DEBUG #define DEBUG 0 diff --git a/parser b/parser new file mode 100755 index 0000000000000000000000000000000000000000..6d64eed3fbcd28afb96fef45560f8a51dc9797bd GIT binary patch literal 36568 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 Date: Thu, 27 Feb 2025 14:13:19 -0500 Subject: [PATCH 06/19] testing why grammar does not work --- calc.h | 48 +++++++++++++++++++++++++++++++++++++++++++ grammar.y | 17 +++++++++++---- lexicalStructure.lex | 2 +- parser | Bin 36568 -> 36592 bytes testGrammar.y | 41 ++++++++++++++++++++++++++++++++++++ 5 files changed, 103 insertions(+), 5 deletions(-) create mode 100644 calc.h create mode 100644 testGrammar.y diff --git a/calc.h b/calc.h new file mode 100644 index 0000000..2580e93 --- /dev/null +++ b/calc.h @@ -0,0 +1,48 @@ +/* Function type. */ +typedef double (func_t) (double); +/* Data type for links in the chain of symbols. */ +struct symrec +{ + char *name; /* name of symbol */ + int type; /* type of symbol: either VAR or FUN */ + union + { + double var; /* value of a VAR */ + func_t *fun; /* value of a FUN */ + } value; + struct symrec *next; /* link field */ +}; +typedef struct symrec symrec; + +/* The symbol table: a chain of 'struct symrec'. */ +extern symrec *sym_table; + +symrec *putsym (char const *name, int sym_type); +symrec *getsym (char const *name); +struct init +{ + char const *name; + func_t *fun; +}; +struct init const funs[] = +{ + { "atan", atan }, + { "cos", cos }, + { "exp", exp }, + { "ln", log }, + { "sin", sin }, + { "sqrt", sqrt }, + { 0, 0 }, +}; +/* The symbol table: a chain of 'struct symrec'. */ +symrec *sym_table; +/* Put functions in table. */ +static void +init_table (void) +{ + for (int i = 0; funs[i].name; i++) + { + symrec *ptr = putsym (funs[i].name, FUN); + ptr->value.fun = funs[i].fun; + } +} diff --git a/grammar.y b/grammar.y index 2bd520d..0b31edb 100644 --- a/grammar.y +++ b/grammar.y @@ -8,9 +8,9 @@ extern int yylex(void); void yyerror(const char *err); %} -/* + %token ID 101 -%token T_INTEGER 201 +%token T_INTEGER %token T_ADDRESS 202 %token T_BOOLEAN 203 %token T_CHARACTER 204 @@ -54,10 +54,19 @@ %token DOT 612 %token RESERVE 613 %token RELEASE 614 -%token COMMENT 700 */ +%token COMMENT 700 %% -start: /*empty for now*/ +input: /*empty for now*/ + OPTIONAL; + +OPTIONAL_OPTIONAL: + OPTIONAL + | OPTIONAL_OPTIONAL OPTIONAL {printf("expansion\n");}; + +OPTIONAL: + '[' {printf("success");} + |%empty ; // B : '{'{CreateScope(cur,line,column)} E '}'; //Braced Expressions can have braces removed to get regular expressions // D : '[' l ']'; //Declaration Lists Brackets can be taken out to get a list of Declarations diff --git a/lexicalStructure.lex b/lexicalStructure.lex index f4fb603..3bd0332 100644 --- a/lexicalStructure.lex +++ b/lexicalStructure.lex @@ -6,7 +6,7 @@ %option header-file="flex.h" %{ #include - #include "typedefs.h" + //#include "typedefs.h" #include "grammar.tab.h" int line_number = 1, column_number = 1; #ifndef DEBUG diff --git a/parser b/parser index 6d64eed3fbcd28afb96fef45560f8a51dc9797bd..432a493003aad234aab1cddeee6bf7bfb3b18924 100755 GIT binary patch delta 10389 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 delta 9977 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 /* For printf, etc. */ + #include /* For pow, used in the grammar. */ + #include "calc.h" /* Contains definition of 'symrec'. */ + int yylex (void); + void yyerror (char const *); +%} +%define api.value.type union /* Generate YYSTYPE from these types: */ +%token NUM /* Double precision number. */ +%token VAR FUN /* Symbol table pointer: variable/function. */ +%nterm exp +%precedence '=' +%left '-' '+' +%left '*' '/' +%precedence NEG /* negation--unary minus */ +%right '^' /* exponentiation */ +%% /* The grammar follows. */ +input: + %empty +| input line +; +line: + '\n' +| exp '\n' { printf ("%.10g\n", $1); } +| error '\n' { yyerrok; } +; +exp: + NUM +| VAR { $$ = $1->value.var; } +| VAR '=' exp { $$ = $3; $1->value.var = $3; } +| FUN '(' exp ')' { $$ = $1->value.fun ($3); } +| exp '+' exp { $$ = $1 + $3; } +| exp '-' exp { $$ = $1 - $3; } +| exp '*' exp { $$ = $1 * $3; } +| exp '/' exp { $$ = $1 / $3; } +| '-' exp %prec NEG { $$ = -$2; } +| exp '^' exp { $$ = pow ($1, $3); } +| '(' exp ')' { $$ = $2; } +; +/* End of grammar. */ +%% From c85540afdfbbd7b864c97d94b5e93fbd564869d1 Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Thu, 27 Feb 2025 15:22:02 -0500 Subject: [PATCH 07/19] updated testing for parser --- grammar.y | 16 +- lex.yy.c | 2100 +++++++++++++++++++++++++++++++++++++++++++++++++++++ parser | Bin 36592 -> 36592 bytes 3 files changed, 2108 insertions(+), 8 deletions(-) create mode 100644 lex.yy.c diff --git a/grammar.y b/grammar.y index 0b31edb..2015769 100644 --- a/grammar.y +++ b/grammar.y @@ -7,6 +7,8 @@ #include "symbol_table.c" extern int yylex(void); void yyerror(const char *err); + extern char* yytext; + extern int yychar; %} %token ID 101 @@ -59,15 +61,9 @@ input: /*empty for now*/ OPTIONAL; - -OPTIONAL_OPTIONAL: - OPTIONAL - | OPTIONAL_OPTIONAL OPTIONAL {printf("expansion\n");}; OPTIONAL: - '[' {printf("success");} - |%empty - ; + '[' {printf("success");}; // B : '{'{CreateScope(cur,line,column)} E '}'; //Braced Expressions can have braces removed to get regular expressions // D : '[' l ']'; //Declaration Lists Brackets can be taken out to get a list of Declarations // E : Maybe_D U; //An expression can start with an optional D followed by an undeclared segment @@ -82,5 +78,9 @@ void yyerror(const char *err) { fprintf(stderr, "Error: %s\n", err); } int main() { - return yyparse(); + int a; + while (a = yyparse()){ + printf("%d = a: yytext = %s: yychar = %d\n", a, yytext, yychar); + } + return 0; } diff --git a/lex.yy.c b/lex.yy.c new file mode 100644 index 0000000..dca4c08 --- /dev/null +++ b/lex.yy.c @@ -0,0 +1,2100 @@ + +#line 3 "lex.yy.c" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. + */ +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN (yy_start) = 1 + 2 * +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START (((yy_start) - 1) / 2) +#define YYSTATE YY_START +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +extern int yyleng; + +extern FILE *yyin, *yyout; + +#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 YY_LINENO_REWIND_TO(ptr) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + 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 ) +#define unput(c) yyunput( c, (yytext_ptr) ) + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = NULL; +static int yy_init = 0; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +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 ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); + +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); + +#define yy_new_buffer yy_create_buffer +#define yy_set_interactive(is_interactive) \ + { \ + 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; \ + } +#define yy_set_bol(at_bol) \ + { \ + 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; \ + } +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ + +#define yywrap() (/*CONSTCOND*/1) +#define YY_SKIP_YYWRAP +typedef flex_uint8_t YY_CHAR; + +FILE *yyin = NULL, *yyout = NULL; + +typedef int yy_state_type; + +extern int yylineno; +int yylineno = 1; + +extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif +#define yytext_ptr yytext + +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 yynoreturn yy_fatal_error ( const char* msg ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ + (yy_c_buf_p) = yy_cp; +#define YY_NUM_RULES 50 +#define YY_END_OF_BUFFER 51 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static const flex_int16_t yy_accept[147] = + { 0, + 0, 0, 51, 49, 47, 46, 48, 24, 49, 20, + 25, 49, 36, 37, 18, 16, 30, 17, 27, 19, + 32, 29, 28, 21, 22, 45, 45, 38, 39, 45, + 45, 45, 45, 45, 45, 45, 45, 45, 40, 26, + 41, 0, 34, 0, 0, 0, 0, 31, 32, 23, + 45, 45, 45, 13, 45, 45, 45, 45, 45, 6, + 45, 45, 45, 45, 45, 45, 45, 33, 0, 0, + 0, 45, 45, 45, 45, 45, 45, 45, 45, 45, + 45, 45, 45, 45, 45, 45, 45, 0, 0, 0, + 35, 0, 45, 45, 45, 8, 45, 45, 45, 45, + + 44, 45, 45, 45, 7, 42, 9, 45, 0, 35, + 0, 0, 45, 45, 45, 45, 43, 45, 45, 45, + 45, 45, 5, 0, 45, 45, 45, 45, 45, 45, + 45, 45, 11, 3, 2, 45, 45, 45, 1, 14, + 15, 45, 12, 10, 4, 0 + } ; + +static const YY_CHAR yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 4, 5, 6, 1, 1, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 18, 18, + 18, 18, 18, 18, 18, 18, 18, 19, 20, 21, + 22, 23, 1, 1, 24, 25, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 26, 27, 28, 1, 24, 1, 29, 24, 30, 31, + + 32, 33, 34, 35, 36, 24, 24, 37, 24, 38, + 39, 40, 24, 41, 42, 43, 44, 45, 46, 47, + 48, 24, 49, 50, 51, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static const YY_CHAR yy_meta[52] = + { 0, + 1, 2, 3, 1, 1, 1, 1, 1, 2, 1, + 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, + 1, 1, 1, 4, 4, 1, 1, 1, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, + 1 + } ; + +static const flex_int16_t yy_base[156] = + { 0, + 0, 0, 203, 204, 204, 204, 204, 204, 46, 204, + 204, 175, 189, 204, 204, 204, 204, 177, 204, 204, + 181, 176, 204, 204, 204, 0, 158, 204, 204, 22, + 161, 18, 25, 23, 151, 162, 22, 158, 204, 204, + 204, 52, 204, 53, 183, 51, 55, 204, 173, 204, + 0, 151, 158, 0, 159, 145, 143, 148, 146, 0, + 140, 145, 34, 149, 136, 139, 142, 204, 63, 165, + 69, 139, 134, 133, 141, 140, 129, 140, 137, 131, + 135, 134, 121, 126, 131, 130, 124, 71, 73, 75, + 204, 81, 128, 127, 129, 0, 116, 124, 112, 120, + + 0, 124, 111, 110, 0, 0, 0, 118, 86, 204, + 88, 90, 120, 106, 117, 108, 0, 109, 112, 101, + 97, 103, 0, 92, 102, 97, 95, 108, 72, 69, + 75, 63, 0, 0, 0, 58, 51, 34, 0, 0, + 0, 27, 0, 0, 0, 204, 104, 108, 58, 112, + 116, 120, 124, 128, 132 + } ; + +static const flex_int16_t yy_def[156] = + { 0, + 146, 1, 146, 146, 146, 146, 146, 146, 147, 146, + 146, 148, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 149, 149, 146, 146, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 146, 146, + 146, 147, 146, 146, 146, 146, 150, 146, 146, 146, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 146, 150, 151, + 152, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 150, 153, 154, + 146, 152, 149, 149, 149, 149, 149, 149, 149, 149, + + 149, 149, 149, 149, 149, 149, 149, 149, 155, 146, + 153, 154, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 155, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, + 149, 149, 149, 149, 149, 0, 146, 146, 146, 146, + 146, 146, 146, 146, 146 + } ; + +static const flex_int16_t yy_nxt[256] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 4, 26, 27, 28, 4, 29, 30, 31, + 26, 32, 33, 26, 26, 34, 26, 35, 26, 26, + 36, 26, 37, 26, 26, 38, 26, 26, 39, 40, + 41, 43, 53, 58, 56, 60, 64, 43, 42, 45, + 61, 51, 65, 54, 57, 70, 71, 145, 59, 66, + 81, 144, 44, 88, 71, 82, 83, 45, 44, 91, + 92, 88, 71, 110, 111, 88, 71, 143, 45, 142, + 42, 110, 92, 45, 141, 42, 70, 89, 146, 111, + + 88, 71, 70, 89, 42, 42, 140, 42, 45, 139, + 138, 45, 69, 69, 69, 69, 70, 70, 70, 70, + 90, 90, 90, 90, 109, 109, 109, 109, 112, 112, + 112, 112, 124, 124, 124, 124, 137, 136, 135, 134, + 133, 132, 131, 130, 129, 128, 127, 126, 125, 123, + 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, + 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, + 98, 97, 96, 95, 94, 93, 89, 87, 86, 85, + 84, 80, 79, 78, 77, 76, 75, 74, 73, 72, + 49, 68, 67, 63, 62, 55, 52, 50, 49, 48, + + 47, 46, 146, 3, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146 + } ; + +static const flex_int16_t yy_chk[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 9, 30, 33, 32, 34, 37, 42, 44, 46, + 34, 149, 37, 30, 32, 47, 47, 142, 33, 37, + 63, 138, 9, 69, 69, 63, 63, 46, 42, 71, + 71, 88, 88, 89, 89, 90, 90, 137, 46, 136, + 44, 92, 92, 46, 132, 44, 109, 109, 111, 111, + + 112, 112, 124, 124, 147, 147, 131, 147, 148, 130, + 129, 148, 150, 150, 150, 150, 151, 151, 151, 151, + 152, 152, 152, 152, 153, 153, 153, 153, 154, 154, + 154, 154, 155, 155, 155, 155, 128, 127, 126, 125, + 122, 121, 120, 119, 118, 116, 115, 114, 113, 108, + 104, 103, 102, 100, 99, 98, 97, 95, 94, 93, + 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, + 77, 76, 75, 74, 73, 72, 70, 67, 66, 65, + 64, 62, 61, 59, 58, 57, 56, 55, 53, 52, + 49, 45, 38, 36, 35, 31, 27, 22, 21, 18, + + 13, 12, 3, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +extern int yy_flex_debug; +int yy_flex_debug = 0; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#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 +char *yytext; +#line 1 "lexicalStructure.lex" +/* Lexical Analysis with Flex (1.6.0) We used some of the code from this manual */ +/* so we placed the citation here. */ +/* definitions */ +#line 8 "lexicalStructure.lex" + #include + //#include "typedefs.h" + #include "grammar.tab.h" + int line_number = 1, column_number = 1; + #ifndef DEBUG + #define DEBUG 0 + #endif +#line 561 "lex.yy.c" +#line 23 "lexicalStructure.lex" + /* char can be a newline, tab, an escaped quote, or anything but a single quote, an actual line break, an actual tab, or a backslash by itself (to prevent confusion from escaped quote */ + /* similar to above, a string Char (SCHAR) is the same as a CHAR except we cannot have double quotes instead of single quotes. Double quotes need to be escaped in Flex unlike single quotes based on documentation */ +#line 565 "lex.yy.c" + +#define INITIAL 0 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +static int yy_init_globals ( void ); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +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 ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( void ); +#else +extern int yywrap ( void ); +#endif +#endif + +#ifndef YY_NO_UNPUT + + static void yyunput ( int c, char *buf_ptr ); + +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * ); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput ( void ); +#else +static int input ( void ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + int n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex (void); + +#define YY_DECL int yylex (void) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK /*LINTED*/break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_load_buffer_state( ); + } + + { +#line 27 "lexicalStructure.lex" + + +#line 785 "lex.yy.c" + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ + { + yy_cp = (yy_c_buf_p); + + /* Support of yytext. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = (yy_start); +yy_match: + do + { + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 147 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 204 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 29 "lexicalStructure.lex" +{if(DEBUG) {printf( "T_INTEGER: %s (%d)\n", yytext, T_INTEGER);} else {return T_INTEGER;}} + YY_BREAK +case 2: +YY_RULE_SETUP +#line 30 "lexicalStructure.lex" +{if(DEBUG) {printf( "T_ADDRESS: %s (%d)\n", yytext, T_ADDRESS);} else {return T_ADDRESS;}} + YY_BREAK +case 3: +YY_RULE_SETUP +#line 31 "lexicalStructure.lex" +{if(DEBUG) {printf( "T_BOOLEAN: %s (%d)\n", yytext, T_BOOLEAN);} else {return T_BOOLEAN;}} + YY_BREAK +case 4: +YY_RULE_SETUP +#line 32 "lexicalStructure.lex" +{if(DEBUG) {printf( "T_CHARACTER: %s (%d)\n", yytext, T_CHARACTER);} else {return T_CHARACTER;}} + YY_BREAK +case 5: +YY_RULE_SETUP +#line 34 "lexicalStructure.lex" +{if(DEBUG) {printf( "WHILE: %s (%d)\n", yytext, WHILE);} else {return WHILE;}} + YY_BREAK +case 6: +YY_RULE_SETUP +#line 35 "lexicalStructure.lex" +{if(DEBUG) {printf( "IF: %s (%d)\n", yytext, IF);} else {return IF;}} + YY_BREAK +case 7: +YY_RULE_SETUP +#line 36 "lexicalStructure.lex" +{if(DEBUG) {printf( "THEN: %s (%d)\n", yytext, THEN);} else {return THEN;}} + YY_BREAK +case 8: +YY_RULE_SETUP +#line 37 "lexicalStructure.lex" +{if(DEBUG) {printf( "ELSE: %s (%d)\n", yytext, ELSE);} else {return ELSE;}} + YY_BREAK +case 9: +YY_RULE_SETUP +#line 38 "lexicalStructure.lex" +{if(DEBUG) {printf( "TYPE: %s (%d)\n", yytext, TYPE);} else {return TYPE;}} + YY_BREAK +case 10: +YY_RULE_SETUP +#line 39 "lexicalStructure.lex" +{if(DEBUG) {printf( "FUNCTION: %s (%d)\n", yytext, FUNCTION);} else {return FUNCTION;}} + YY_BREAK +case 11: +YY_RULE_SETUP +#line 40 "lexicalStructure.lex" +{if(DEBUG) {printf( "RETURN: %s (%d)\n", yytext, RETURN);} else {return RETURN;}} + YY_BREAK +case 12: +YY_RULE_SETUP +#line 41 "lexicalStructure.lex" +{if(DEBUG) {printf( "EXTERNAL: %s (%d)\n", yytext, EXTERNAL);} else {return EXTERNAL;}} + YY_BREAK +case 13: +YY_RULE_SETUP +#line 42 "lexicalStructure.lex" +{if(DEBUG) {printf( "AS: %s (%d)\n", yytext, AS);} else {return AS;}} + YY_BREAK +case 14: +YY_RULE_SETUP +#line 44 "lexicalStructure.lex" +{if(DEBUG) {printf( "RELEASE: %s (%d)\n", yytext, RELEASE);} else {return RELEASE;}} + YY_BREAK +case 15: +YY_RULE_SETUP +#line 45 "lexicalStructure.lex" +{if(DEBUG) {printf( "RESERVE: %s (%d)\n", yytext, RESERVE);} else {return RESERVE;}} + YY_BREAK +case 16: +YY_RULE_SETUP +#line 47 "lexicalStructure.lex" +{if(DEBUG) {printf( "ADD: %s (%d)\n", yytext, ADD);} else {return ADD;}} + YY_BREAK +case 17: +YY_RULE_SETUP +#line 48 "lexicalStructure.lex" +{if(DEBUG) {printf( "SUB_OR_NEG: %s (%d)\n", yytext, SUB_OR_NEG);} else {return SUB_OR_NEG;}} + YY_BREAK +case 18: +YY_RULE_SETUP +#line 49 "lexicalStructure.lex" +{if(DEBUG) {printf( "MUL: %s (%d)\n", yytext, MUL);} else {return MUL;}} + YY_BREAK +case 19: +YY_RULE_SETUP +#line 50 "lexicalStructure.lex" +{if(DEBUG) {printf( "DIV: %s (%d)\n", yytext, DIV);} else {return DIV;}} + YY_BREAK +case 20: +YY_RULE_SETUP +#line 51 "lexicalStructure.lex" +{if(DEBUG) {printf( "REM: %s (%d)\n", yytext, REM);} else {return REM;}} + YY_BREAK +case 21: +YY_RULE_SETUP +#line 52 "lexicalStructure.lex" +{if(DEBUG) {printf( "LESS_THAN: %s (%d)\n", yytext, LESS_THAN);} else {return LESS_THAN;}} + YY_BREAK +case 22: +YY_RULE_SETUP +#line 53 "lexicalStructure.lex" +{if(DEBUG) {printf( "EQUAL_TO: %s (%d)\n", yytext, EQUAL_TO);} else {return EQUAL_TO;}} + YY_BREAK +case 23: +YY_RULE_SETUP +#line 54 "lexicalStructure.lex" +{if(DEBUG) {printf( "ASSIGN: %s (%d)\n", yytext, ASSIGN);} else {return ASSIGN;}} + YY_BREAK +case 24: +YY_RULE_SETUP +#line 55 "lexicalStructure.lex" +{if(DEBUG) {printf( "NOT: %s (%d)\n", yytext, NOT);} else {return NOT;}} + YY_BREAK +case 25: +YY_RULE_SETUP +#line 56 "lexicalStructure.lex" +{if(DEBUG) {printf( "AND: %s (%d)\n", yytext, AND);} else {return AND;}} + YY_BREAK +case 26: +YY_RULE_SETUP +#line 57 "lexicalStructure.lex" +{if(DEBUG) {printf( "OR: %s (%d)\n", yytext, OR);} else {return OR;}} + YY_BREAK +case 27: +YY_RULE_SETUP +#line 58 "lexicalStructure.lex" +{if(DEBUG) {printf( "DOT: %s (%d)\n", yytext, DOT);} else {return DOT;}} + YY_BREAK +case 28: +YY_RULE_SETUP +#line 60 "lexicalStructure.lex" +{if(DEBUG) {printf( "SEMI_COLON: %s (%d)\n", yytext, SEMI_COLON);} else {return SEMI_COLON;}} + YY_BREAK +case 29: +YY_RULE_SETUP +#line 61 "lexicalStructure.lex" +{if(DEBUG) {printf( "COLON: %s (%d)\n", yytext, COLON);} else {return COLON;}} + YY_BREAK +case 30: +YY_RULE_SETUP +#line 62 "lexicalStructure.lex" +{if(DEBUG) {printf( "COMMA: %s (%d)\n", yytext, COMMA);} else {return COMMA;}} + YY_BREAK +case 31: +YY_RULE_SETUP +#line 63 "lexicalStructure.lex" +{if(DEBUG) {printf( "ARROW: %s (%d)\n", yytext, ARROW);} else {return ARROW;}} + YY_BREAK +case 32: +YY_RULE_SETUP +#line 65 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_INTEGER: %s (%d)\n", yytext, C_INTEGER);} else {return C_INTEGER;}} + YY_BREAK +case 33: +YY_RULE_SETUP +#line 66 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_CHARACTER: %s (%d)\n", yytext, C_CHARACTER);} else {return C_CHARACTER;}} + YY_BREAK +case 34: +YY_RULE_SETUP +#line 67 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_STRING: %s (%d)\n", yytext, C_STRING);} else {return C_STRING;}} + YY_BREAK +case 35: +/* rule 35 can match eol */ +YY_RULE_SETUP +#line 68 "lexicalStructure.lex" +{if(DEBUG) {printf( "COMMENT: %s (%d)\n", yytext, COMMENT);} else {return COMMENT;}} + YY_BREAK +case 36: +YY_RULE_SETUP +#line 70 "lexicalStructure.lex" +{if(DEBUG) {printf( "L_PAREN: %s (%d)\n", yytext, L_PAREN);} else {return L_PAREN;}} + YY_BREAK +case 37: +YY_RULE_SETUP +#line 71 "lexicalStructure.lex" +{if(DEBUG) {printf( "R_PAREN: %s (%d)\n", yytext, R_PAREN);} else {return R_PAREN;}} + YY_BREAK +case 38: +YY_RULE_SETUP +#line 73 "lexicalStructure.lex" +{if(DEBUG) {printf( "L_BRACKET: %s (%d)\n", yytext, L_BRACKET);} else {return L_BRACKET;}} + YY_BREAK +case 39: +YY_RULE_SETUP +#line 74 "lexicalStructure.lex" +{if(DEBUG) {printf( "R_BRACKET: %s (%d)\n", yytext, R_BRACKET);} else {return R_BRACKET;}} + YY_BREAK +case 40: +YY_RULE_SETUP +#line 76 "lexicalStructure.lex" +{if(DEBUG) {printf( "L_BRACE: %s (%d)\n", yytext, L_BRACE);} else {return L_BRACE;}} + YY_BREAK +case 41: +YY_RULE_SETUP +#line 77 "lexicalStructure.lex" +{if(DEBUG) {printf( "R_BRACE: %s (%d)\n", yytext, R_BRACE);} else {return R_BRACE;}} + YY_BREAK +case 42: +YY_RULE_SETUP +#line 79 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_TRUE: %s (%d)\n", yytext, C_TRUE);} else {return C_TRUE;}} + YY_BREAK +case 43: +YY_RULE_SETUP +#line 80 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_FALSE: %s (%d)\n", yytext, C_FALSE);} else {return C_FALSE;}} + YY_BREAK +case 44: +YY_RULE_SETUP +#line 81 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_NULL: %s (%d)\n", yytext, C_NULL);} else {return C_NULL;}} + YY_BREAK +case 45: +YY_RULE_SETUP +#line 83 "lexicalStructure.lex" +{if(DEBUG) {printf( "ID: %s (%d)\n", yytext, ID);} else {return ID;}} + YY_BREAK +case 46: +/* rule 46 can match eol */ +YY_RULE_SETUP +#line 85 "lexicalStructure.lex" +{line_number++; column_number = 1;} + YY_BREAK +case 47: +YY_RULE_SETUP +#line 86 "lexicalStructure.lex" +{column_number++;} + YY_BREAK +case 48: +YY_RULE_SETUP +#line 87 "lexicalStructure.lex" +{column_number++;} + YY_BREAK +case 49: +YY_RULE_SETUP +#line 88 "lexicalStructure.lex" +{column_number++; return 1999;} + YY_BREAK +case 50: +YY_RULE_SETUP +#line 90 "lexicalStructure.lex" +ECHO; + YY_BREAK +#line 1094 "lex.yy.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = (yy_c_buf_p); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of user's declarations */ +} /* end of yylex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (void) +{ + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = (yytext_ptr); + int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (void) +{ + yy_state_type yy_current_state; + char *yy_cp; + + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 147 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +{ + int yy_is_jam; + char *yy_cp = (yy_c_buf_p); + + YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 147 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 146); + + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_UNPUT + + static void yyunput (int c, char * yy_bp ) +{ + char *yy_cp; + + yy_cp = (yy_c_buf_p); + + /* undo effects of setting up yytext */ + *yy_cp = (yy_hold_char); + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + int number_to_move = (yy_n_chars) + 2; + char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; + char *source = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; + + while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = + (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + (yytext_ptr) = yy_bp; + (yy_hold_char) = *yy_cp; + (yy_c_buf_p) = yy_cp; +} + +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (void) +#else + static int input (void) +#endif + +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( ) ) + return 0; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyrestart (FILE * input_file ) +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + +static void yy_load_buffer_state (void) +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + (yy_hold_char) = *(yy_c_buf_p); +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ + void yy_delete_buffer (YY_BUFFER_STATE b ) +{ + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree( (void *) b->yy_ch_buf ); + + yyfree( (void *) b ); +} + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) + +{ + int oerrno = errno; + + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ + void yy_flush_buffer (YY_BUFFER_STATE b ) +{ + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +void yypop_buffer_state (void) +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void yyensure_buffer_stack (void) +{ + yy_size_t num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + yy_size_t grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return NULL; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = NULL; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (const char * yystr ) +{ + + return yy_scan_bytes( yystr, (int) strlen(yystr) ); +} + +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yynoreturn yy_fatal_error (const char* msg ) +{ + fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + 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 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the current line number. + * + */ +int yyget_lineno (void) +{ + + return yylineno; +} + +/** Get the input stream. + * + */ +FILE *yyget_in (void) +{ + return yyin; +} + +/** Get the output stream. + * + */ +FILE *yyget_out (void) +{ + return yyout; +} + +/** Get the length of the current token. + * + */ +int yyget_leng (void) +{ + return yyleng; +} + +/** Get the current token. + * + */ + +char *yyget_text (void) +{ + return yytext; +} + +/** Set the current line number. + * @param _line_number line number + * + */ +void yyset_lineno (int _line_number ) +{ + + yylineno = _line_number; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param _in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * _in_str ) +{ + yyin = _in_str ; +} + +void yyset_out (FILE * _out_str ) +{ + yyout = _out_str ; +} + +int yyget_debug (void) +{ + return yy_flex_debug; +} + +void yyset_debug (int _bdebug ) +{ + yy_flex_debug = _bdebug ; +} + +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + (yy_buffer_stack) = NULL; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = NULL; + (yy_init) = 0; + (yy_start) = 0; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = NULL; + yyout = NULL; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} + +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer( YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } + + /* Destroy the stack itself. */ + yyfree((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( ); + + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, const char * s2, int n ) +{ + + int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (const char * s ) +{ + int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size ) +{ + return malloc(size); +} + +void *yyrealloc (void * ptr, yy_size_t size ) +{ + + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return realloc(ptr, size); +} + +void yyfree (void * ptr ) +{ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 90 "lexicalStructure.lex" + + diff --git a/parser b/parser index 432a493003aad234aab1cddeee6bf7bfb3b18924..d8cc1d741f18e0e6e768cac2bbd19e597fd2efc8 100755 GIT binary patch delta 9604 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 V)_J04t;|`!)@0gVSyvHZ`ab~#xXl0n From f355de059f6a8608b0c1edd2d66e42941628049e Mon Sep 17 00:00:00 2001 From: Meyer Simon Date: Thu, 27 Feb 2025 16:11:13 -0500 Subject: [PATCH 08/19] added some test files nothing is working t#34 --- library.alpha | 30 ++++++++++++++++++++++++++++++ simple.alpha | 4 ++++ 2 files changed, 34 insertions(+) create mode 100644 library.alpha create mode 100644 simple.alpha diff --git a/library.alpha b/library.alpha new file mode 100644 index 0000000..9bacd6c --- /dev/null +++ b/library.alpha @@ -0,0 +1,30 @@ +(* At compiler start-up your program should create symbol table entries for the four primitive types: + Boolean (1 byte) + character (1 byte) + integer (4 bytes) + address (8 bytes) +You should #include this file at the start of your alpha file. +Some useful types are defined below. +*) +type string: 1 -> character +type BooleanXBoolean: [Boolean: x, y] +type characterXcharacter: [character: x, y] +type integerXinteger: [integer: x, y] + +type Boolean2Boolean: Boolean -> Boolean +type integer2integer: integer -> integer +type character2integer: character -> integer +type Boolean2integer: Boolean -> integer +type string2integer: string -> integer +type integerXinteger2integer: integerXinteger -> integer +type integerXinteger2Boolean: integerXinteger -> Boolean +type characterXcharacter2Boolean: characterXcharacter -> Boolean +type BooleanXBoolean2Boolean: BooleanXBoolean -> Boolean +type integer2address: integer -> address +type address2integer: address -> integer +external function printInteger: integer2integer +external function printCharacter: character2integer +external function printBoolean: Boolean2integer +external function reserve: integer2address +external function release: address2integer +function entry: string2integer diff --git a/simple.alpha b/simple.alpha new file mode 100644 index 0000000..13f3c9f --- /dev/null +++ b/simple.alpha @@ -0,0 +1,4 @@ +#include "library.alpha" +entry(arg) := { + return 0; +} From 77596a9d96d29e46dcea21e591f19b08d44f2a9f Mon Sep 17 00:00:00 2001 From: Meyer Simon Date: Thu, 27 Feb 2025 17:02:17 -0500 Subject: [PATCH 09/19] got it to workgit add grammar.ygit add grammar.ygit add grammar.ygit add grammar.ygit add grammar.ygit add grammar.ygit add grammar.y! t#34 --- grammar.y | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/grammar.y b/grammar.y index 2015769..0ce008e 100644 --- a/grammar.y +++ b/grammar.y @@ -63,7 +63,7 @@ input: /*empty for now*/ OPTIONAL; OPTIONAL: - '[' {printf("success");}; + L_BRACKET {printf("success");}; // B : '{'{CreateScope(cur,line,column)} E '}'; //Braced Expressions can have braces removed to get regular expressions // D : '[' l ']'; //Declaration Lists Brackets can be taken out to get a list of Declarations // E : Maybe_D U; //An expression can start with an optional D followed by an undeclared segment @@ -76,7 +76,7 @@ OPTIONAL: void yyerror(const char *err) { fprintf(stderr, "Error: %s\n", err); -} +} int main() { int a; while (a = yyparse()){ From fad44e21ea5f6994c63175a933fb880dfea67c42 Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Thu, 27 Feb 2025 17:58:01 -0500 Subject: [PATCH 10/19] added print table functionality to main in grammar.y with custom EOF input in '!' --- grammar.y | 22 ++++++++++++---------- parser | Bin 36592 -> 36648 bytes symbol_table.c | 10 ++++++++++ 3 files changed, 22 insertions(+), 10 deletions(-) diff --git a/grammar.y b/grammar.y index 0ce008e..c267eeb 100644 --- a/grammar.y +++ b/grammar.y @@ -8,7 +8,9 @@ extern int yylex(void); void yyerror(const char *err); extern char* yytext; - extern int yychar; + extern int yychar; + SymbolTable * st; + %} %token ID 101 @@ -59,28 +61,28 @@ %token COMMENT 700 %% -input: /*empty for now*/ +start: /*empty for now*/ OPTIONAL; OPTIONAL: L_BRACKET {printf("success");}; -// B : '{'{CreateScope(cur,line,column)} E '}'; //Braced Expressions can have braces removed to get regular expressions -// D : '[' l ']'; //Declaration Lists Brackets can be taken out to get a list of Declarations -// E : Maybe_D U; //An expression can start with an optional D followed by an undeclared segment -// Maybe_D : D -// | ; //Either D or not -//l : A ';' l; -// | ; //a declaration list can either be empty or be an assignment followed by a semi-colon and another list +// %% void yyerror(const char *err) { fprintf(stderr, "Error: %s\n", err); } + int main() { + st=CreateScope(NULL,1,1); int a; - while (a = yyparse()){ + while ((a = yyparse()) != EOF){ printf("%d = a: yytext = %s: yychar = %d\n", a, yytext, yychar); + if(yytext[0] == '!'){ + print_symbol_table(getAncestor(st),stdout); + break; + } } return 0; } diff --git a/parser b/parser index d8cc1d741f18e0e6e768cac2bbd19e597fd2efc8..3a559de4d69ab532788655642731e6d46596d7d6 100755 GIT binary patch delta 10114 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%0D)YzVvfZmQY|R>iWIxh373^^cFgCA6p0U zG{gh@*oP47AwJm0PC;xB-=t62x_K6_SctYy*ln<*A@=^1wViA6nh!BTh@}vNK4l}p z?t$1|u%{uaf~|-6u!6g_#}>L%!EIw9{wUbd5NicHAL2JcEQNRsB68RR@l*wSVV=c) z8sdh7hLMb96>A6o)#^}RuleoUU}BUWsP)kAf_`gry|vgwEfqFIhoc5!FNPd4j90KC z?l`dXnB9gOlFb0vJpT{F$iwnW8B>zw(p6v>}Rmy5b<2=Fx%pl39&;Bi-TAIQLkZRAr?XWt%kh> zaRP>`!BF{VCkHEaDjaY@e;(%LTrS%Rv3h029^jm9pbzTtk)ci*HnlF z7uZOMOCdfj#O)9#$hZ)P3EN8$(=M=6ux*4`bb;N57>e2Vtz~VoxzZuFt7W~Ow}ecE z7>HvThG}=N%|t9qMMS$%9xP_T08?YdvkTgI+CPJVN$IGB;|m29emw(^q7r`v--@VU zB)pu!U*d1H;%g*-OY&GWUj8Zh`d0jP!P}KzqyoE+mpY+P?zQ6YOa8v(T?svwe1qh% zs=OGIZ*0YT(y>zfl`n(I3{UnLZjQHLC_I&W=Uu5{-z)1n~zBB?#lO8bW754Pf0Nxrfbzk~A~l}daf zq!NWTl@BGa;F~8elHV(MyQ1KWFqM7+6#8OD%bh8C{sA1iO34@D3pf=QUnTj|$Y@set*snyp^RVB=pMZ1QI7Uk$Uo6evtrN{?+gmgM0V%uc=fX3tX*g6CHOL>047 z>L2;pz(p!|b6Xa$B*@2)v}%CT$liagw>bbuBBx0ByEc7qw(qr|XNSuu<7AZ1!br)J z{M1ZA_)C5Uc#5{RND!`QbEJJmmf(9zdn?OY5)`sfYQK~V{*KhHV1Iyios3yjBxp2w z*+LoGKa#$q&4QgFwH1=TDtQk~FqPwyS2B4M*@{vl`HeEerzHPR$zPIunB?io!Tdh0 z1Y`;(NGk3~hr&UE@GuE%l>AOPl`=2I3r|0PB?PyC3?QKsP0ffXXlX*1NUdu^W5Lt% zE*UJ$uu)DXqHNV-Va&KGu{D{d>VgM4gf$QPqf@PU~MCWx2I(re5>(e{=zc#qp#l*vVc zciA^kw1jrJNNGkM$%Sxj)gZ}Fl83ZhI4d#Cv^2<`Cbb{Q?2D)~Ql69j+bgIFc`|7w-PS;_Cg|3{+oz5wNl;Cm_M ztvdb*3L5a#B4Ozo@Xzet(x8OLGTd{myi~m8(Bhqu8^v`h+p*kbL8egp8xjv2+G^o4 zvdlzDV=I;gX(ON&TXmL@*U@;LT|@LjY_g7Ods@X7gPU-8E zzW*(4Dp=O?!)#;G+zMm)CR4@lMa3p{(c%jG%0SgS>!n%GEn58YD;008x~NtxTyxb! zeI}lb*W-K|vxIvibLiQoVpgNa2dpX(oC|NTfYSJYxibap!lf0trFN5PFRLlDn=)DM Yn<+kPmkX2QY&}|ISBsW~1vtX~52zn;#Q*>R delta 9845 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

yUNog5GTY(7yJgyF2R@IMI8B$ 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 WJivR(8sT!3UEDmtParent_Scope, x); } + +SymbolTable * getAncestor(SymbolTable * table){ + if(table->Parent_Scope == NULL){ + //if table has no parent, return itself + return table; + } else { + //call function recursively to grab ancestor + return getAncestor(table->Parent_Scope); + } +} void print_symbol_table(SymbolTable *table, FILE *file_ptr){ if(table->Parent_Scope == NULL){ fprintf(file_ptr, "%-17s: %-6s : %-6s : %-21s: %-28s\n", "NAME", "SCOPE", "PARENT", "TYPE", "Extra annotation"); From d609dd2dca2da6a5af3adad67a568e0dc307fb81 Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Thu, 27 Feb 2025 20:03:50 -0500 Subject: [PATCH 11/19] added skeleton rules and grammar to bison file --- grammar.y | 125 +++++++++++++++++++++++++++++++++++++++++++++++++++--- parser | Bin 36648 -> 40856 bytes 2 files changed, 119 insertions(+), 6 deletions(-) diff --git a/grammar.y b/grammar.y index c267eeb..adb4aa7 100644 --- a/grammar.y +++ b/grammar.y @@ -10,7 +10,8 @@ extern char* yytext; extern int yychar; SymbolTable * st; - + char* cur_value; + char* cur_type; %} %token ID 101 @@ -61,12 +62,122 @@ %token COMMENT 700 %% -start: /*empty for now*/ - OPTIONAL; +program: + prototype_or_definition_list; -OPTIONAL: - L_BRACKET {printf("success");}; +prototype_or_definition_list: + prototype prototype_or_definition_list + | definition prototype_or_definition_list + | prototype + | definition + ; +prototype: + L_PAREN EXTERNAL R_PAREN FUNCTION ID COLON ID; +definition: + TYPE ID COLON dblock + | TYPE ID COLON constant ARROW ID + | TYPE ID COLON ID ARROW ID + | ID parameter ASSIGN sblock + ; + +parameter: + L_PAREN ID R_PAREN + | AS L_PAREN idlist R_PAREN + ; + +idlist: + ID COMMA idlist + |ID + ; + +sblock: + L_BRACE {st = CreateScope(st,1,1);} statement_list {st = getParent(st);} R_BRACE + | L_BRACE {st = CreateScope(st,1,1);} dblock statement_list {st = getParent(st);} R_BRACE + ; + +dblock: + L_BRACKET declaration_list R_BRACKET; + +declaration_list: + declaration {CreateEntry(st,cur_type,cur_value);} SEMI_COLON declaration_list + | declaration {CreateEntry(st,cur_type,cur_value);} + ; + +declaration: + ID COLON ID {cur_value = strdup($1);cur_type = strdup($3);}; + +statement_list: + compound_statement statement_list + | compound_statement + | simple_statement SEMI_COLON statement_list + | simple_statement SEMI_COLON + ; + +compound_statement: + WHILE L_PAREN expression R_PAREN sblock + | IF L_PAREN expression R_PAREN THEN sblock ELSE sblock + | sblock + ; + +simple_statement: + assignable ASSIGN expression + | RETURN expression + ; + +assignable: + ID + | assignable ablock + | assignable DOT ID + ; + +expression: + constant + | UnaryOperator expression + | assignable + | expression binaryOperator expression + | L_PAREN expression R_PAREN + | memOp assignable + ; + +ablock: + L_PAREN argument_list R_PAREN; + +argument_list: + expression COMMA argument_list + | expression + ; + +UnaryOperator: + SUB_OR_NEG + | NOT + ; + +memOp: + RESERVE + | RELEASE + ; + +binaryOperator: + ADD + | SUB_OR_NEG + | MUL + | DIV + | REM + | AND + | OR + | LESS_THAN + | EQUAL_TO + ; + +constant: + C_STRING + | C_INTEGER + | C_NULL + | C_CHARACTER + | C_TRUE + | C_FALSE + ; // %% @@ -75,11 +186,13 @@ void yyerror(const char *err) { } int main() { + cur_value[1] = ""; + cur_type[1] = ""; st=CreateScope(NULL,1,1); int a; while ((a = yyparse()) != EOF){ printf("%d = a: yytext = %s: yychar = %d\n", a, yytext, yychar); - if(yytext[0] == '!'){ + if(yytext[0] == '?'){ print_symbol_table(getAncestor(st),stdout); break; } diff --git a/parser b/parser index 3a559de4d69ab532788655642731e6d46596d7d6..05d2da9e80dd27dbbb7f6f3bb90bc8855f15ec55 100755 GIT binary patch delta 13761 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 delta 12450 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 From 078b059d1c34eceb01a0819b1e722d7a8fb981f2 Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Thu, 27 Feb 2025 20:28:39 -0500 Subject: [PATCH 12/19] parser compiling --- grammar.y | 11 ++++++++--- parser | Bin 40856 -> 40856 bytes 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/grammar.y b/grammar.y index adb4aa7..f9f14e8 100644 --- a/grammar.y +++ b/grammar.y @@ -14,7 +14,12 @@ char* cur_type; %} -%token ID 101 +%union { + int integ; + char * words; +} + +%token ID 101 %token T_INTEGER %token T_ADDRESS 202 %token T_BOOLEAN 203 @@ -186,8 +191,8 @@ void yyerror(const char *err) { } int main() { - cur_value[1] = ""; - cur_type[1] = ""; + cur_value = NULL; + cur_type = NULL; st=CreateScope(NULL,1,1); int a; while ((a = yyparse()) != EOF){ diff --git a/parser b/parser index 05d2da9e80dd27dbbb7f6f3bb90bc8855f15ec55..cb59b833bc9d5254ff75b3e6fa3d5e61bcbefe06 100755 GIT binary patch delta 8886 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%0A>O< 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 From 046cb4b171e2e659193910deb749b63a8da29c88 Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Fri, 28 Feb 2025 11:50:18 -0500 Subject: [PATCH 13/19] solved shift-reduce errors --- grammar.y | 26 ++++++++++++++++++++++---- parser | Bin 40856 -> 40856 bytes 2 files changed, 22 insertions(+), 4 deletions(-) diff --git a/grammar.y b/grammar.y index f9f14e8..ca54a25 100644 --- a/grammar.y +++ b/grammar.y @@ -18,6 +18,22 @@ int integ; char * words; } +//precedence order +%precedence RESERVE +%precedence RELEASE +%precedence DOT +%precedence SUB_OR_NEG +%precedence NOT +%left MUL +%left DIV +%left REM +%left ADD +//need subtraction only here +%left LESS_THAN +%left EQUAL_TO +%left AND +%left OR +%left ASSIGN %token ID 101 %token T_INTEGER @@ -50,7 +66,7 @@ %token COLON 508 %token COMMA 509 %token ARROW 510 -%token ADD 601 +/* %token ADD 601 %token SUB_OR_NEG 602 %token MUL 603 %token DIV 604 @@ -63,8 +79,10 @@ %token OR 611 %token DOT 612 %token RESERVE 613 -%token RELEASE 614 +%token RELEASE 614 */ %token COMMENT 700 + + %% program: @@ -140,7 +158,7 @@ expression: constant | UnaryOperator expression | assignable - | expression binaryOperator expression + | constant binaryOperator expression | L_PAREN expression R_PAREN | memOp assignable ; @@ -197,7 +215,7 @@ int main() { int a; while ((a = yyparse()) != EOF){ printf("%d = a: yytext = %s: yychar = %d\n", a, yytext, yychar); - if(yytext[0] == '?'){ + if(yytext[0] == '!'){ print_symbol_table(getAncestor(st),stdout); break; } diff --git a/parser b/parser index cb59b833bc9d5254ff75b3e6fa3d5e61bcbefe06..02e2648389b3dc49b093d9cc710c25095f792e19 100755 GIT binary patch delta 8853 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≺O?XzdCH|>SUmn* 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 sx1LY(Dlg)#m$Q`Z#bP8|yFJOP=l|i@y*uSk From d4b943b83840b34256287a005483a93ae282e6cd Mon Sep 17 00:00:00 2001 From: Meyer Simon Date: Fri, 28 Feb 2025 12:16:21 -0500 Subject: [PATCH 14/19] added an alpha file all on one line --- tests/test_real_alpha_file_oneline.alpha | 1 + 1 file changed, 1 insertion(+) create mode 100644 tests/test_real_alpha_file_oneline.alpha diff --git a/tests/test_real_alpha_file_oneline.alpha b/tests/test_real_alpha_file_oneline.alpha new file mode 100644 index 0000000..423b6e3 --- /dev/null +++ b/tests/test_real_alpha_file_oneline.alpha @@ -0,0 +1 @@ +type rec: [integer: x; integer: y] type T1: integer -> integer type T2: rec -> integer function foo : T1 function bar1 : T2 function bar2 : T2 foo(x) := { return x * x; } bar1(a) := { return a.x * a.y; } bar2 as (r,s) := { return r * s; } entry(arg) := { [ integer: result ; rec: w] result := foo(5); w := reserve(w); (* see types.alpha – reserve returns a value of type address, which can be assigned to array and record variables *) w.x := 5; w.y := 7; result := bar1(w); (* pass w (a rec type value) to bar1 *) result := bar2(5,7); (* implicitly build a rec type value, assign 5 and 7 to fields x and y, but call them r and s *) return 0; } From 32e123beb715cab5f03c2773c4edba2f6e17796a Mon Sep 17 00:00:00 2001 From: Meyer Simon Date: Fri, 28 Feb 2025 12:21:36 -0500 Subject: [PATCH 15/19] forgot to remove the comments --- tests/test_real_alpha_file_oneline.alpha | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_real_alpha_file_oneline.alpha b/tests/test_real_alpha_file_oneline.alpha index 423b6e3..01f115e 100644 --- a/tests/test_real_alpha_file_oneline.alpha +++ b/tests/test_real_alpha_file_oneline.alpha @@ -1 +1 @@ -type rec: [integer: x; integer: y] type T1: integer -> integer type T2: rec -> integer function foo : T1 function bar1 : T2 function bar2 : T2 foo(x) := { return x * x; } bar1(a) := { return a.x * a.y; } bar2 as (r,s) := { return r * s; } entry(arg) := { [ integer: result ; rec: w] result := foo(5); w := reserve(w); (* see types.alpha – reserve returns a value of type address, which can be assigned to array and record variables *) w.x := 5; w.y := 7; result := bar1(w); (* pass w (a rec type value) to bar1 *) result := bar2(5,7); (* implicitly build a rec type value, assign 5 and 7 to fields x and y, but call them r and s *) return 0; } +type rec: [integer: x; integer: y] type T1: integer -> integer type T2: rec -> integer function foo : T1 function bar1 : T2 function bar2 : T2 foo(x) := { return x * x; } bar1(a) := { return a.x * a.y; } bar2 as (r,s) := { return r * s; } entry(arg) := { [ integer: result ; rec: w] result := foo(5); w := reserve(w); w.x := 5; w.y := 7; result := bar1(w); result := bar2(5,7); return 0; } From 2808a75dc9be9c397cd48f3c113566ef24b6729f Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Fri, 28 Feb 2025 14:03:53 -0500 Subject: [PATCH 16/19] edited some grammar rules. Still running into syntax errors --- .Makefile.swp | Bin 0 -> 12288 bytes Makefile | 7 + grammar.y | 42 +- lex.yy.c | 2100 ------------------------------------------------- parser | Bin 40856 -> 0 bytes 5 files changed, 38 insertions(+), 2111 deletions(-) create mode 100644 .Makefile.swp delete mode 100644 lex.yy.c delete mode 100755 parser diff --git a/.Makefile.swp b/.Makefile.swp new file mode 100644 index 0000000000000000000000000000000000000000..731dce035acfa5772ee102a56adbe2804c3e8404 GIT binary patch literal 12288 zcmeI2y>HV%7>5s72$T;&2PBpQiqryjN-0uhsY7W?RjEvTRst2rxqMK^w$2wIs`ywK zkeFD2e}KZk!hi$=A3H2;?0{7M02UbdonxnU;?M|*0rW1P*w1(6@Z-{^FZcJdpfEbBo7a0eLYCIc(eazQ!@T3#VVHM9F*iV<0Uy9y@B%D@$KVdQ z1TKO}V1Oea2R4J1?Kls-2T#Fma0{FV2f+aNv5m1e;5B##9)XA81}K9PxC|`N2fp?p zA3Ov#Fai3(x2Q6Bcfk_yz&w}&k&l0H zJ!#5hfDDiUGC&5%z~3{FlQnLX_#rb?EdIMJ?OM&2rm_oWC9Ba%8V{MuUrY{4uDHIM zKQK6bVR|Tu=}@C#t~t?Xjw@`>!hbntzM0I8P;oP_M5w~(ePK~FuKBVUnzkEM?6yn; zW2e*oK*;Dx%g%hA+tIxgw!08@y)cq}N@_NLo~|GI>|ubgS_@n;S5+v(%_zE~;N}Ul zo;m|(Jq+OEiBuWXJ*Su4-^)yy>Ap@KQ!WcnS9iu=6kdw&%T8+2PXiLl-C7qM*+hNV9>051q^kD^MW)#qx zhv6huIPq+Ck8!vatMGUW)t#N3o4ycPXjMHhsGC@F9MxNOZ1=R1bw|~uFcD%bS(Gdv z%@L!?&QECHsZ~kVNALSi*6LtQ0$YYcuBuL*!{X?gp;K{=uca84TjRWWQLy-mvBnve bTDLbhdK9V;P)}!pT8s{ASFG7t*>Tt}gkE>x literal 0 HcmV?d00001 diff --git a/Makefile b/Makefile index 05aff7a..8f3879c 100644 --- a/Makefile +++ b/Makefile @@ -3,6 +3,13 @@ FLEX := flex LEX := lexicalStructure.lex EXE := alpha CFLAGS := +YACC := bison + +parser : lex.yy.c grammar.tab.c + $(CC) -o parser lex.yy.c grammar.tab.c + +grammar.tab.c: grammar.y + $(YACC) -d grammar.y compiler: lex.yy.c runner.o runner diff --git a/grammar.y b/grammar.y index ca54a25..e10b99f 100644 --- a/grammar.y +++ b/grammar.y @@ -12,6 +12,9 @@ SymbolTable * st; char* cur_value; char* cur_type; + int token_tracker; + extern int line_number; + extern int column_number; %} %union { @@ -100,6 +103,8 @@ prototype: definition: TYPE ID COLON dblock | TYPE ID COLON constant ARROW ID + | TYPE ID COLON types ARROW ID + | FUNCTION ID COLON ID | TYPE ID COLON ID ARROW ID | ID parameter ASSIGN sblock ; @@ -115,20 +120,22 @@ idlist: ; sblock: - L_BRACE {st = CreateScope(st,1,1);} statement_list {st = getParent(st);} R_BRACE - | L_BRACE {st = CreateScope(st,1,1);} dblock statement_list {st = getParent(st);} R_BRACE + L_BRACE /*{st = CreateScope(st,1,1);}*/ statement_list /*{st = getParent(st);}*/ R_BRACE + | L_BRACE /*{st = CreateScope(st,1,1);}*/ dblock statement_list /*{st = getParent(st);}*/ R_BRACE ; dblock: L_BRACKET declaration_list R_BRACKET; declaration_list: - declaration {CreateEntry(st,cur_type,cur_value);} SEMI_COLON declaration_list - | declaration {CreateEntry(st,cur_type,cur_value);} + declaration /*{CreateEntry(st,cur_type,cur_value);}*/ SEMI_COLON declaration_list + | declaration //{CreateEntry(st,cur_type,cur_value);} ; declaration: - ID COLON ID {cur_value = strdup($1);cur_type = strdup($3);}; + ID COLON ID //{cur_value = strdup($1);cur_type = strdup($3);} + | types COLON ID + ; statement_list: compound_statement statement_list @@ -201,22 +208,35 @@ constant: | C_TRUE | C_FALSE ; + +types: + T_STRING + | T_INTEGER + | T_ADDRESS + | T_CHARACTER + | T_BOOLEAN + ; // %% void yyerror(const char *err) { - fprintf(stderr, "Error: %s\n", err); + fprintf(stderr, "ERROR: %s at token %s at line number %d,column number %d\n", err,yytext,line_number,column_number); } int main() { - cur_value = NULL; - cur_type = NULL; + //cur_value = NULL; + //cur_type = NULL; + + token_tracker = 1; st=CreateScope(NULL,1,1); int a; while ((a = yyparse()) != EOF){ - printf("%d = a: yytext = %s: yychar = %d\n", a, yytext, yychar); - if(yytext[0] == '!'){ - print_symbol_table(getAncestor(st),stdout); + token_tracker++; + //printf("%d = a: yytext = %s: yychar = %d, token number: %d\n", a, yytext, yychar,token_tracker); + if(yytext[0] == '\n'){ + FILE* f = fdopen(1,"w"); + print_symbol_table(getAncestor(st),f); + fclose(f); break; } } diff --git a/lex.yy.c b/lex.yy.c deleted file mode 100644 index dca4c08..0000000 --- a/lex.yy.c +++ /dev/null @@ -1,2100 +0,0 @@ - -#line 3 "lex.yy.c" - -#define YY_INT_ALIGNED short int - -/* A lexical scanner generated by flex */ - -#define FLEX_SCANNER -#define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 6 -#define YY_FLEX_SUBMINOR_VERSION 4 -#if YY_FLEX_SUBMINOR_VERSION > 0 -#define FLEX_BETA -#endif - -/* First, we deal with platform-specific or compiler-specific issues. */ - -/* begin standard C headers. */ -#include -#include -#include -#include - -/* end standard C headers. */ - -/* flex integer type definitions */ - -#ifndef FLEXINT_H -#define FLEXINT_H - -/* C99 systems have . Non-C99 systems may or may not. */ - -#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - -/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. - */ -#ifndef __STDC_LIMIT_MACROS -#define __STDC_LIMIT_MACROS 1 -#endif - -#include -typedef int8_t flex_int8_t; -typedef uint8_t flex_uint8_t; -typedef int16_t flex_int16_t; -typedef uint16_t flex_uint16_t; -typedef int32_t flex_int32_t; -typedef uint32_t flex_uint32_t; -#else -typedef signed char flex_int8_t; -typedef short int flex_int16_t; -typedef int flex_int32_t; -typedef unsigned char flex_uint8_t; -typedef unsigned short int flex_uint16_t; -typedef unsigned int flex_uint32_t; - -/* Limits of integral types. */ -#ifndef INT8_MIN -#define INT8_MIN (-128) -#endif -#ifndef INT16_MIN -#define INT16_MIN (-32767-1) -#endif -#ifndef INT32_MIN -#define INT32_MIN (-2147483647-1) -#endif -#ifndef INT8_MAX -#define INT8_MAX (127) -#endif -#ifndef INT16_MAX -#define INT16_MAX (32767) -#endif -#ifndef INT32_MAX -#define INT32_MAX (2147483647) -#endif -#ifndef UINT8_MAX -#define UINT8_MAX (255U) -#endif -#ifndef UINT16_MAX -#define UINT16_MAX (65535U) -#endif -#ifndef UINT32_MAX -#define UINT32_MAX (4294967295U) -#endif - -#ifndef SIZE_MAX -#define SIZE_MAX (~(size_t)0) -#endif - -#endif /* ! C99 */ - -#endif /* ! FLEXINT_H */ - -/* begin standard C++ headers. */ - -/* TODO: this is always defined, so inline it */ -#define yyconst const - -#if defined(__GNUC__) && __GNUC__ >= 3 -#define yynoreturn __attribute__((__noreturn__)) -#else -#define yynoreturn -#endif - -/* Returned upon end-of-file. */ -#define YY_NULL 0 - -/* Promotes a possibly negative, possibly signed char to an - * integer in range [0..255] for use as an array index. - */ -#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) - -/* Enter a start condition. This macro really ought to take a parameter, - * but we do it the disgusting crufty way forced on us by the ()-less - * definition of BEGIN. - */ -#define BEGIN (yy_start) = 1 + 2 * -/* Translate the current start state into a value that can be later handed - * to BEGIN to return to the state. The YYSTATE alias is for lex - * compatibility. - */ -#define YY_START (((yy_start) - 1) / 2) -#define YYSTATE YY_START -/* Action number for EOF rule of a given start state. */ -#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) -/* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE yyrestart( yyin ) -#define YY_END_OF_BUFFER_CHAR 0 - -/* Size of default input buffer. */ -#ifndef YY_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k. - * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. - * Ditto for the __ia64__ case accordingly. - */ -#define YY_BUF_SIZE 32768 -#else -#define YY_BUF_SIZE 16384 -#endif /* __ia64__ */ -#endif - -/* The state buf must be large enough to hold one state per character in the main buffer. - */ -#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) - -#ifndef YY_TYPEDEF_YY_BUFFER_STATE -#define YY_TYPEDEF_YY_BUFFER_STATE -typedef struct yy_buffer_state *YY_BUFFER_STATE; -#endif - -#ifndef YY_TYPEDEF_YY_SIZE_T -#define YY_TYPEDEF_YY_SIZE_T -typedef size_t yy_size_t; -#endif - -extern int yyleng; - -extern FILE *yyin, *yyout; - -#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 YY_LINENO_REWIND_TO(ptr) - -/* Return all but the first "n" matched characters back to the input stream. */ -#define yyless(n) \ - 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 ) -#define unput(c) yyunput( c, (yytext_ptr) ) - -#ifndef YY_STRUCT_YY_BUFFER_STATE -#define YY_STRUCT_YY_BUFFER_STATE -struct yy_buffer_state - { - FILE *yy_input_file; - - char *yy_ch_buf; /* input buffer */ - char *yy_buf_pos; /* current position in input buffer */ - - /* Size of input buffer in bytes, not including room for EOB - * characters. - */ - int yy_buf_size; - - /* Number of characters read into yy_ch_buf, not including EOB - * characters. - */ - int yy_n_chars; - - /* Whether we "own" the buffer - i.e., we know we created it, - * and can realloc() it to grow it, and should free() it to - * delete it. - */ - int yy_is_our_buffer; - - /* Whether this is an "interactive" input source; if so, and - * if we're using stdio for input, then we want to use getc() - * instead of fread(), to make sure we stop fetching input after - * each newline. - */ - int yy_is_interactive; - - /* Whether we're considered to be at the beginning of a line. - * If so, '^' rules will be active on the next match, otherwise - * not. - */ - int yy_at_bol; - - int yy_bs_lineno; /**< The line count. */ - int yy_bs_column; /**< The column count. */ - - /* Whether to try to fill the input buffer when we reach the - * end of it. - */ - int yy_fill_buffer; - - int yy_buffer_status; - -#define YY_BUFFER_NEW 0 -#define YY_BUFFER_NORMAL 1 - /* When an EOF's been seen but there's still some text to process - * then we mark the buffer as YY_EOF_PENDING, to indicate that we - * shouldn't try reading from the input source any more. We might - * still have a bunch of tokens to match, though, because of - * possible backing-up. - * - * When we actually see the EOF, we change the status to "new" - * (via yyrestart()), so that the user can continue scanning by - * just pointing yyin at a new input file. - */ -#define YY_BUFFER_EOF_PENDING 2 - - }; -#endif /* !YY_STRUCT_YY_BUFFER_STATE */ - -/* Stack of input buffers. */ -static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ -static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ -static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ - -/* We provide macros for accessing buffer states in case in the - * future we want to put the buffer states in a more general - * "scanner state". - * - * Returns the top of the stack, or NULL. - */ -#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ - ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ - : NULL) -/* Same as previous macro, but useful when we know that the buffer stack is not - * NULL or when we need an lvalue. For internal use only. - */ -#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] - -/* yy_hold_char holds the character lost when yytext is formed. */ -static char yy_hold_char; -static int yy_n_chars; /* number of characters read into yy_ch_buf */ -int yyleng; - -/* Points to current character in buffer. */ -static char *yy_c_buf_p = NULL; -static int yy_init = 0; /* whether we need to initialize */ -static int yy_start = 0; /* start state number */ - -/* Flag which is used to allow yywrap()'s to do buffer switches - * instead of setting up a fresh yyin. A bit of a hack ... - */ -static int yy_did_buffer_switch_on_eof; - -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 ); -#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) - -YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); -YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); -YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); - -void *yyalloc ( yy_size_t ); -void *yyrealloc ( void *, yy_size_t ); -void yyfree ( void * ); - -#define yy_new_buffer yy_create_buffer -#define yy_set_interactive(is_interactive) \ - { \ - 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; \ - } -#define yy_set_bol(at_bol) \ - { \ - 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; \ - } -#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) - -/* Begin user sect3 */ - -#define yywrap() (/*CONSTCOND*/1) -#define YY_SKIP_YYWRAP -typedef flex_uint8_t YY_CHAR; - -FILE *yyin = NULL, *yyout = NULL; - -typedef int yy_state_type; - -extern int yylineno; -int yylineno = 1; - -extern char *yytext; -#ifdef yytext_ptr -#undef yytext_ptr -#endif -#define yytext_ptr yytext - -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 yynoreturn yy_fatal_error ( const char* msg ); - -/* Done after the current pattern has been matched and before the - * corresponding action - sets up yytext. - */ -#define YY_DO_BEFORE_ACTION \ - (yytext_ptr) = yy_bp; \ - yyleng = (int) (yy_cp - yy_bp); \ - (yy_hold_char) = *yy_cp; \ - *yy_cp = '\0'; \ - (yy_c_buf_p) = yy_cp; -#define YY_NUM_RULES 50 -#define YY_END_OF_BUFFER 51 -/* This struct is not used in this scanner, - but its presence is necessary. */ -struct yy_trans_info - { - flex_int32_t yy_verify; - flex_int32_t yy_nxt; - }; -static const flex_int16_t yy_accept[147] = - { 0, - 0, 0, 51, 49, 47, 46, 48, 24, 49, 20, - 25, 49, 36, 37, 18, 16, 30, 17, 27, 19, - 32, 29, 28, 21, 22, 45, 45, 38, 39, 45, - 45, 45, 45, 45, 45, 45, 45, 45, 40, 26, - 41, 0, 34, 0, 0, 0, 0, 31, 32, 23, - 45, 45, 45, 13, 45, 45, 45, 45, 45, 6, - 45, 45, 45, 45, 45, 45, 45, 33, 0, 0, - 0, 45, 45, 45, 45, 45, 45, 45, 45, 45, - 45, 45, 45, 45, 45, 45, 45, 0, 0, 0, - 35, 0, 45, 45, 45, 8, 45, 45, 45, 45, - - 44, 45, 45, 45, 7, 42, 9, 45, 0, 35, - 0, 0, 45, 45, 45, 45, 43, 45, 45, 45, - 45, 45, 5, 0, 45, 45, 45, 45, 45, 45, - 45, 45, 11, 3, 2, 45, 45, 45, 1, 14, - 15, 45, 12, 10, 4, 0 - } ; - -static const YY_CHAR yy_ec[256] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 4, 5, 6, 1, 1, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 18, 18, - 18, 18, 18, 18, 18, 18, 18, 19, 20, 21, - 22, 23, 1, 1, 24, 25, 24, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, - 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, - 26, 27, 28, 1, 24, 1, 29, 24, 30, 31, - - 32, 33, 34, 35, 36, 24, 24, 37, 24, 38, - 39, 40, 24, 41, 42, 43, 44, 45, 46, 47, - 48, 24, 49, 50, 51, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1 - } ; - -static const YY_CHAR yy_meta[52] = - { 0, - 1, 2, 3, 1, 1, 1, 1, 1, 2, 1, - 1, 1, 1, 1, 1, 1, 1, 4, 1, 1, - 1, 1, 1, 4, 4, 1, 1, 1, 4, 4, - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, - 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, - 1 - } ; - -static const flex_int16_t yy_base[156] = - { 0, - 0, 0, 203, 204, 204, 204, 204, 204, 46, 204, - 204, 175, 189, 204, 204, 204, 204, 177, 204, 204, - 181, 176, 204, 204, 204, 0, 158, 204, 204, 22, - 161, 18, 25, 23, 151, 162, 22, 158, 204, 204, - 204, 52, 204, 53, 183, 51, 55, 204, 173, 204, - 0, 151, 158, 0, 159, 145, 143, 148, 146, 0, - 140, 145, 34, 149, 136, 139, 142, 204, 63, 165, - 69, 139, 134, 133, 141, 140, 129, 140, 137, 131, - 135, 134, 121, 126, 131, 130, 124, 71, 73, 75, - 204, 81, 128, 127, 129, 0, 116, 124, 112, 120, - - 0, 124, 111, 110, 0, 0, 0, 118, 86, 204, - 88, 90, 120, 106, 117, 108, 0, 109, 112, 101, - 97, 103, 0, 92, 102, 97, 95, 108, 72, 69, - 75, 63, 0, 0, 0, 58, 51, 34, 0, 0, - 0, 27, 0, 0, 0, 204, 104, 108, 58, 112, - 116, 120, 124, 128, 132 - } ; - -static const flex_int16_t yy_def[156] = - { 0, - 146, 1, 146, 146, 146, 146, 146, 146, 147, 146, - 146, 148, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 149, 149, 146, 146, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 146, 146, - 146, 147, 146, 146, 146, 146, 150, 146, 146, 146, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 146, 150, 151, - 152, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 150, 153, 154, - 146, 152, 149, 149, 149, 149, 149, 149, 149, 149, - - 149, 149, 149, 149, 149, 149, 149, 149, 155, 146, - 153, 154, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 155, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 149, 149, 149, 149, 149, 0, 146, 146, 146, 146, - 146, 146, 146, 146, 146 - } ; - -static const flex_int16_t yy_nxt[256] = - { 0, - 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, - 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, - 24, 25, 4, 26, 27, 28, 4, 29, 30, 31, - 26, 32, 33, 26, 26, 34, 26, 35, 26, 26, - 36, 26, 37, 26, 26, 38, 26, 26, 39, 40, - 41, 43, 53, 58, 56, 60, 64, 43, 42, 45, - 61, 51, 65, 54, 57, 70, 71, 145, 59, 66, - 81, 144, 44, 88, 71, 82, 83, 45, 44, 91, - 92, 88, 71, 110, 111, 88, 71, 143, 45, 142, - 42, 110, 92, 45, 141, 42, 70, 89, 146, 111, - - 88, 71, 70, 89, 42, 42, 140, 42, 45, 139, - 138, 45, 69, 69, 69, 69, 70, 70, 70, 70, - 90, 90, 90, 90, 109, 109, 109, 109, 112, 112, - 112, 112, 124, 124, 124, 124, 137, 136, 135, 134, - 133, 132, 131, 130, 129, 128, 127, 126, 125, 123, - 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, - 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, - 98, 97, 96, 95, 94, 93, 89, 87, 86, 85, - 84, 80, 79, 78, 77, 76, 75, 74, 73, 72, - 49, 68, 67, 63, 62, 55, 52, 50, 49, 48, - - 47, 46, 146, 3, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146 - } ; - -static const flex_int16_t yy_chk[256] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 9, 30, 33, 32, 34, 37, 42, 44, 46, - 34, 149, 37, 30, 32, 47, 47, 142, 33, 37, - 63, 138, 9, 69, 69, 63, 63, 46, 42, 71, - 71, 88, 88, 89, 89, 90, 90, 137, 46, 136, - 44, 92, 92, 46, 132, 44, 109, 109, 111, 111, - - 112, 112, 124, 124, 147, 147, 131, 147, 148, 130, - 129, 148, 150, 150, 150, 150, 151, 151, 151, 151, - 152, 152, 152, 152, 153, 153, 153, 153, 154, 154, - 154, 154, 155, 155, 155, 155, 128, 127, 126, 125, - 122, 121, 120, 119, 118, 116, 115, 114, 113, 108, - 104, 103, 102, 100, 99, 98, 97, 95, 94, 93, - 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, - 77, 76, 75, 74, 73, 72, 70, 67, 66, 65, - 64, 62, 61, 59, 58, 57, 56, 55, 53, 52, - 49, 45, 38, 36, 35, 31, 27, 22, 21, 18, - - 13, 12, 3, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, - 146, 146, 146, 146, 146 - } ; - -static yy_state_type yy_last_accepting_state; -static char *yy_last_accepting_cpos; - -extern int yy_flex_debug; -int yy_flex_debug = 0; - -/* The intent behind this definition is that it'll catch - * any uses of REJECT which flex missed. - */ -#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 -char *yytext; -#line 1 "lexicalStructure.lex" -/* Lexical Analysis with Flex (1.6.0) We used some of the code from this manual */ -/* so we placed the citation here. */ -/* definitions */ -#line 8 "lexicalStructure.lex" - #include - //#include "typedefs.h" - #include "grammar.tab.h" - int line_number = 1, column_number = 1; - #ifndef DEBUG - #define DEBUG 0 - #endif -#line 561 "lex.yy.c" -#line 23 "lexicalStructure.lex" - /* char can be a newline, tab, an escaped quote, or anything but a single quote, an actual line break, an actual tab, or a backslash by itself (to prevent confusion from escaped quote */ - /* similar to above, a string Char (SCHAR) is the same as a CHAR except we cannot have double quotes instead of single quotes. Double quotes need to be escaped in Flex unlike single quotes based on documentation */ -#line 565 "lex.yy.c" - -#define INITIAL 0 - -#ifndef YY_NO_UNISTD_H -/* Special case for "unistd.h", since it is non-ANSI. We include it way - * down here because we want the user's section 1 to have been scanned first. - * The user has a chance to override it with an option. - */ -#include -#endif - -#ifndef YY_EXTRA_TYPE -#define YY_EXTRA_TYPE void * -#endif - -static int yy_init_globals ( void ); - -/* Accessor methods to globals. - These are made visible to non-reentrant scanners for convenience. */ - -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 ); - -/* Macros after this point can all be overridden by user definitions in - * section 1. - */ - -#ifndef YY_SKIP_YYWRAP -#ifdef __cplusplus -extern "C" int yywrap ( void ); -#else -extern int yywrap ( void ); -#endif -#endif - -#ifndef YY_NO_UNPUT - - static void yyunput ( int c, char *buf_ptr ); - -#endif - -#ifndef yytext_ptr -static void yy_flex_strncpy ( char *, const char *, int ); -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen ( const char * ); -#endif - -#ifndef YY_NO_INPUT -#ifdef __cplusplus -static int yyinput ( void ); -#else -static int input ( void ); -#endif - -#endif - -/* Amount of stuff to slurp up with each read. */ -#ifndef YY_READ_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k */ -#define YY_READ_BUF_SIZE 16384 -#else -#define YY_READ_BUF_SIZE 8192 -#endif /* __ia64__ */ -#endif - -/* Copy whatever the last rule matched to the standard output. */ -#ifndef ECHO -/* This used to be an fputs(), but since the string might contain NUL's, - * we now use fwrite(). - */ -#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) -#endif - -/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, - * is returned in "result". - */ -#ifndef YY_INPUT -#define YY_INPUT(buf,result,max_size) \ - if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ - { \ - int c = '*'; \ - int n; \ - for ( n = 0; n < max_size && \ - (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ - buf[n] = (char) c; \ - if ( c == '\n' ) \ - buf[n++] = (char) c; \ - if ( c == EOF && ferror( yyin ) ) \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - result = n; \ - } \ - else \ - { \ - errno=0; \ - while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ - { \ - if( errno != EINTR) \ - { \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - break; \ - } \ - errno=0; \ - clearerr(yyin); \ - } \ - }\ -\ - -#endif - -/* No semi-colon after return; correct usage is to write "yyterminate();" - - * we don't want an extra ';' after the "return" because that will cause - * some compilers to complain about unreachable statements. - */ -#ifndef yyterminate -#define yyterminate() return YY_NULL -#endif - -/* Number of entries by which start-condition stack grows. */ -#ifndef YY_START_STACK_INCR -#define YY_START_STACK_INCR 25 -#endif - -/* Report a fatal error. */ -#ifndef YY_FATAL_ERROR -#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) -#endif - -/* end tables serialization structures and prototypes */ - -/* Default declaration of generated scanner - a define so the user can - * easily add parameters. - */ -#ifndef YY_DECL -#define YY_DECL_IS_OURS 1 - -extern int yylex (void); - -#define YY_DECL int yylex (void) -#endif /* !YY_DECL */ - -/* Code executed at the beginning of each rule, after yytext and yyleng - * have been set up. - */ -#ifndef YY_USER_ACTION -#define YY_USER_ACTION -#endif - -/* Code executed at the end of each rule. */ -#ifndef YY_BREAK -#define YY_BREAK /*LINTED*/break; -#endif - -#define YY_RULE_SETUP \ - YY_USER_ACTION - -/** The main scanner function which does all the work. - */ -YY_DECL -{ - yy_state_type yy_current_state; - char *yy_cp, *yy_bp; - int yy_act; - - if ( !(yy_init) ) - { - (yy_init) = 1; - -#ifdef YY_USER_INIT - YY_USER_INIT; -#endif - - if ( ! (yy_start) ) - (yy_start) = 1; /* first start state */ - - if ( ! yyin ) - yyin = stdin; - - if ( ! yyout ) - yyout = stdout; - - if ( ! YY_CURRENT_BUFFER ) { - yyensure_buffer_stack (); - YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer( yyin, YY_BUF_SIZE ); - } - - yy_load_buffer_state( ); - } - - { -#line 27 "lexicalStructure.lex" - - -#line 785 "lex.yy.c" - - while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ - { - yy_cp = (yy_c_buf_p); - - /* Support of yytext. */ - *yy_cp = (yy_hold_char); - - /* yy_bp points to the position in yy_ch_buf of the start of - * the current run. - */ - yy_bp = yy_cp; - - yy_current_state = (yy_start); -yy_match: - do - { - YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 147 ) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - ++yy_cp; - } - while ( yy_base[yy_current_state] != 204 ); - -yy_find_action: - yy_act = yy_accept[yy_current_state]; - if ( yy_act == 0 ) - { /* have to back up */ - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - yy_act = yy_accept[yy_current_state]; - } - - YY_DO_BEFORE_ACTION; - -do_action: /* This label is used only to access EOF actions. */ - - switch ( yy_act ) - { /* beginning of action switch */ - case 0: /* must back up */ - /* undo the effects of YY_DO_BEFORE_ACTION */ - *yy_cp = (yy_hold_char); - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - goto yy_find_action; - -case 1: -YY_RULE_SETUP -#line 29 "lexicalStructure.lex" -{if(DEBUG) {printf( "T_INTEGER: %s (%d)\n", yytext, T_INTEGER);} else {return T_INTEGER;}} - YY_BREAK -case 2: -YY_RULE_SETUP -#line 30 "lexicalStructure.lex" -{if(DEBUG) {printf( "T_ADDRESS: %s (%d)\n", yytext, T_ADDRESS);} else {return T_ADDRESS;}} - YY_BREAK -case 3: -YY_RULE_SETUP -#line 31 "lexicalStructure.lex" -{if(DEBUG) {printf( "T_BOOLEAN: %s (%d)\n", yytext, T_BOOLEAN);} else {return T_BOOLEAN;}} - YY_BREAK -case 4: -YY_RULE_SETUP -#line 32 "lexicalStructure.lex" -{if(DEBUG) {printf( "T_CHARACTER: %s (%d)\n", yytext, T_CHARACTER);} else {return T_CHARACTER;}} - YY_BREAK -case 5: -YY_RULE_SETUP -#line 34 "lexicalStructure.lex" -{if(DEBUG) {printf( "WHILE: %s (%d)\n", yytext, WHILE);} else {return WHILE;}} - YY_BREAK -case 6: -YY_RULE_SETUP -#line 35 "lexicalStructure.lex" -{if(DEBUG) {printf( "IF: %s (%d)\n", yytext, IF);} else {return IF;}} - YY_BREAK -case 7: -YY_RULE_SETUP -#line 36 "lexicalStructure.lex" -{if(DEBUG) {printf( "THEN: %s (%d)\n", yytext, THEN);} else {return THEN;}} - YY_BREAK -case 8: -YY_RULE_SETUP -#line 37 "lexicalStructure.lex" -{if(DEBUG) {printf( "ELSE: %s (%d)\n", yytext, ELSE);} else {return ELSE;}} - YY_BREAK -case 9: -YY_RULE_SETUP -#line 38 "lexicalStructure.lex" -{if(DEBUG) {printf( "TYPE: %s (%d)\n", yytext, TYPE);} else {return TYPE;}} - YY_BREAK -case 10: -YY_RULE_SETUP -#line 39 "lexicalStructure.lex" -{if(DEBUG) {printf( "FUNCTION: %s (%d)\n", yytext, FUNCTION);} else {return FUNCTION;}} - YY_BREAK -case 11: -YY_RULE_SETUP -#line 40 "lexicalStructure.lex" -{if(DEBUG) {printf( "RETURN: %s (%d)\n", yytext, RETURN);} else {return RETURN;}} - YY_BREAK -case 12: -YY_RULE_SETUP -#line 41 "lexicalStructure.lex" -{if(DEBUG) {printf( "EXTERNAL: %s (%d)\n", yytext, EXTERNAL);} else {return EXTERNAL;}} - YY_BREAK -case 13: -YY_RULE_SETUP -#line 42 "lexicalStructure.lex" -{if(DEBUG) {printf( "AS: %s (%d)\n", yytext, AS);} else {return AS;}} - YY_BREAK -case 14: -YY_RULE_SETUP -#line 44 "lexicalStructure.lex" -{if(DEBUG) {printf( "RELEASE: %s (%d)\n", yytext, RELEASE);} else {return RELEASE;}} - YY_BREAK -case 15: -YY_RULE_SETUP -#line 45 "lexicalStructure.lex" -{if(DEBUG) {printf( "RESERVE: %s (%d)\n", yytext, RESERVE);} else {return RESERVE;}} - YY_BREAK -case 16: -YY_RULE_SETUP -#line 47 "lexicalStructure.lex" -{if(DEBUG) {printf( "ADD: %s (%d)\n", yytext, ADD);} else {return ADD;}} - YY_BREAK -case 17: -YY_RULE_SETUP -#line 48 "lexicalStructure.lex" -{if(DEBUG) {printf( "SUB_OR_NEG: %s (%d)\n", yytext, SUB_OR_NEG);} else {return SUB_OR_NEG;}} - YY_BREAK -case 18: -YY_RULE_SETUP -#line 49 "lexicalStructure.lex" -{if(DEBUG) {printf( "MUL: %s (%d)\n", yytext, MUL);} else {return MUL;}} - YY_BREAK -case 19: -YY_RULE_SETUP -#line 50 "lexicalStructure.lex" -{if(DEBUG) {printf( "DIV: %s (%d)\n", yytext, DIV);} else {return DIV;}} - YY_BREAK -case 20: -YY_RULE_SETUP -#line 51 "lexicalStructure.lex" -{if(DEBUG) {printf( "REM: %s (%d)\n", yytext, REM);} else {return REM;}} - YY_BREAK -case 21: -YY_RULE_SETUP -#line 52 "lexicalStructure.lex" -{if(DEBUG) {printf( "LESS_THAN: %s (%d)\n", yytext, LESS_THAN);} else {return LESS_THAN;}} - YY_BREAK -case 22: -YY_RULE_SETUP -#line 53 "lexicalStructure.lex" -{if(DEBUG) {printf( "EQUAL_TO: %s (%d)\n", yytext, EQUAL_TO);} else {return EQUAL_TO;}} - YY_BREAK -case 23: -YY_RULE_SETUP -#line 54 "lexicalStructure.lex" -{if(DEBUG) {printf( "ASSIGN: %s (%d)\n", yytext, ASSIGN);} else {return ASSIGN;}} - YY_BREAK -case 24: -YY_RULE_SETUP -#line 55 "lexicalStructure.lex" -{if(DEBUG) {printf( "NOT: %s (%d)\n", yytext, NOT);} else {return NOT;}} - YY_BREAK -case 25: -YY_RULE_SETUP -#line 56 "lexicalStructure.lex" -{if(DEBUG) {printf( "AND: %s (%d)\n", yytext, AND);} else {return AND;}} - YY_BREAK -case 26: -YY_RULE_SETUP -#line 57 "lexicalStructure.lex" -{if(DEBUG) {printf( "OR: %s (%d)\n", yytext, OR);} else {return OR;}} - YY_BREAK -case 27: -YY_RULE_SETUP -#line 58 "lexicalStructure.lex" -{if(DEBUG) {printf( "DOT: %s (%d)\n", yytext, DOT);} else {return DOT;}} - YY_BREAK -case 28: -YY_RULE_SETUP -#line 60 "lexicalStructure.lex" -{if(DEBUG) {printf( "SEMI_COLON: %s (%d)\n", yytext, SEMI_COLON);} else {return SEMI_COLON;}} - YY_BREAK -case 29: -YY_RULE_SETUP -#line 61 "lexicalStructure.lex" -{if(DEBUG) {printf( "COLON: %s (%d)\n", yytext, COLON);} else {return COLON;}} - YY_BREAK -case 30: -YY_RULE_SETUP -#line 62 "lexicalStructure.lex" -{if(DEBUG) {printf( "COMMA: %s (%d)\n", yytext, COMMA);} else {return COMMA;}} - YY_BREAK -case 31: -YY_RULE_SETUP -#line 63 "lexicalStructure.lex" -{if(DEBUG) {printf( "ARROW: %s (%d)\n", yytext, ARROW);} else {return ARROW;}} - YY_BREAK -case 32: -YY_RULE_SETUP -#line 65 "lexicalStructure.lex" -{if(DEBUG) {printf( "C_INTEGER: %s (%d)\n", yytext, C_INTEGER);} else {return C_INTEGER;}} - YY_BREAK -case 33: -YY_RULE_SETUP -#line 66 "lexicalStructure.lex" -{if(DEBUG) {printf( "C_CHARACTER: %s (%d)\n", yytext, C_CHARACTER);} else {return C_CHARACTER;}} - YY_BREAK -case 34: -YY_RULE_SETUP -#line 67 "lexicalStructure.lex" -{if(DEBUG) {printf( "C_STRING: %s (%d)\n", yytext, C_STRING);} else {return C_STRING;}} - YY_BREAK -case 35: -/* rule 35 can match eol */ -YY_RULE_SETUP -#line 68 "lexicalStructure.lex" -{if(DEBUG) {printf( "COMMENT: %s (%d)\n", yytext, COMMENT);} else {return COMMENT;}} - YY_BREAK -case 36: -YY_RULE_SETUP -#line 70 "lexicalStructure.lex" -{if(DEBUG) {printf( "L_PAREN: %s (%d)\n", yytext, L_PAREN);} else {return L_PAREN;}} - YY_BREAK -case 37: -YY_RULE_SETUP -#line 71 "lexicalStructure.lex" -{if(DEBUG) {printf( "R_PAREN: %s (%d)\n", yytext, R_PAREN);} else {return R_PAREN;}} - YY_BREAK -case 38: -YY_RULE_SETUP -#line 73 "lexicalStructure.lex" -{if(DEBUG) {printf( "L_BRACKET: %s (%d)\n", yytext, L_BRACKET);} else {return L_BRACKET;}} - YY_BREAK -case 39: -YY_RULE_SETUP -#line 74 "lexicalStructure.lex" -{if(DEBUG) {printf( "R_BRACKET: %s (%d)\n", yytext, R_BRACKET);} else {return R_BRACKET;}} - YY_BREAK -case 40: -YY_RULE_SETUP -#line 76 "lexicalStructure.lex" -{if(DEBUG) {printf( "L_BRACE: %s (%d)\n", yytext, L_BRACE);} else {return L_BRACE;}} - YY_BREAK -case 41: -YY_RULE_SETUP -#line 77 "lexicalStructure.lex" -{if(DEBUG) {printf( "R_BRACE: %s (%d)\n", yytext, R_BRACE);} else {return R_BRACE;}} - YY_BREAK -case 42: -YY_RULE_SETUP -#line 79 "lexicalStructure.lex" -{if(DEBUG) {printf( "C_TRUE: %s (%d)\n", yytext, C_TRUE);} else {return C_TRUE;}} - YY_BREAK -case 43: -YY_RULE_SETUP -#line 80 "lexicalStructure.lex" -{if(DEBUG) {printf( "C_FALSE: %s (%d)\n", yytext, C_FALSE);} else {return C_FALSE;}} - YY_BREAK -case 44: -YY_RULE_SETUP -#line 81 "lexicalStructure.lex" -{if(DEBUG) {printf( "C_NULL: %s (%d)\n", yytext, C_NULL);} else {return C_NULL;}} - YY_BREAK -case 45: -YY_RULE_SETUP -#line 83 "lexicalStructure.lex" -{if(DEBUG) {printf( "ID: %s (%d)\n", yytext, ID);} else {return ID;}} - YY_BREAK -case 46: -/* rule 46 can match eol */ -YY_RULE_SETUP -#line 85 "lexicalStructure.lex" -{line_number++; column_number = 1;} - YY_BREAK -case 47: -YY_RULE_SETUP -#line 86 "lexicalStructure.lex" -{column_number++;} - YY_BREAK -case 48: -YY_RULE_SETUP -#line 87 "lexicalStructure.lex" -{column_number++;} - YY_BREAK -case 49: -YY_RULE_SETUP -#line 88 "lexicalStructure.lex" -{column_number++; return 1999;} - YY_BREAK -case 50: -YY_RULE_SETUP -#line 90 "lexicalStructure.lex" -ECHO; - YY_BREAK -#line 1094 "lex.yy.c" -case YY_STATE_EOF(INITIAL): - yyterminate(); - - case YY_END_OF_BUFFER: - { - /* Amount of text matched not including the EOB char. */ - int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; - - /* Undo the effects of YY_DO_BEFORE_ACTION. */ - *yy_cp = (yy_hold_char); - YY_RESTORE_YY_MORE_OFFSET - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) - { - /* We're scanning a new file or input source. It's - * possible that this happened because the user - * just pointed yyin at a new source and called - * yylex(). If so, then we have to assure - * consistency between YY_CURRENT_BUFFER and our - * globals. Here is the right place to do so, because - * this is the first action (other than possibly a - * back-up) that will match for the new input source. - */ - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; - } - - /* Note that here we test for yy_c_buf_p "<=" to the position - * of the first EOB in the buffer, since yy_c_buf_p will - * already have been incremented past the NUL character - * (since all states make transitions on EOB to the - * end-of-buffer state). Contrast this with the test - * in input(). - */ - if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) - { /* This was really a NUL. */ - yy_state_type yy_next_state; - - (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( ); - - /* Okay, we're now positioned to make the NUL - * transition. We couldn't have - * yy_get_previous_state() go ahead and do it - * for us because it doesn't know how to deal - * with the possibility of jamming (and we don't - * want to build jamming into it because then it - * will run more slowly). - */ - - yy_next_state = yy_try_NUL_trans( yy_current_state ); - - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - - if ( yy_next_state ) - { - /* Consume the NUL. */ - yy_cp = ++(yy_c_buf_p); - yy_current_state = yy_next_state; - goto yy_match; - } - - else - { - yy_cp = (yy_c_buf_p); - goto yy_find_action; - } - } - - else switch ( yy_get_next_buffer( ) ) - { - case EOB_ACT_END_OF_FILE: - { - (yy_did_buffer_switch_on_eof) = 0; - - if ( yywrap( ) ) - { - /* Note: because we've taken care in - * yy_get_next_buffer() to have set up - * yytext, we can now set up - * yy_c_buf_p so that if some total - * hoser (like flex itself) wants to - * call the scanner after we return the - * YY_NULL, it'll still work - another - * YY_NULL will get returned. - */ - (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; - - yy_act = YY_STATE_EOF(YY_START); - goto do_action; - } - - else - { - if ( ! (yy_did_buffer_switch_on_eof) ) - YY_NEW_FILE; - } - break; - } - - case EOB_ACT_CONTINUE_SCAN: - (yy_c_buf_p) = - (yytext_ptr) + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( ); - - yy_cp = (yy_c_buf_p); - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - goto yy_match; - - case EOB_ACT_LAST_MATCH: - (yy_c_buf_p) = - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; - - yy_current_state = yy_get_previous_state( ); - - yy_cp = (yy_c_buf_p); - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - goto yy_find_action; - } - break; - } - - default: - YY_FATAL_ERROR( - "fatal flex scanner internal error--no action found" ); - } /* end of action switch */ - } /* end of scanning one token */ - } /* end of user's declarations */ -} /* end of yylex */ - -/* yy_get_next_buffer - try to read in a new buffer - * - * Returns a code representing an action: - * EOB_ACT_LAST_MATCH - - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position - * EOB_ACT_END_OF_FILE - end of file - */ -static int yy_get_next_buffer (void) -{ - char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - char *source = (yytext_ptr); - int number_to_move, i; - int ret_val; - - if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) - YY_FATAL_ERROR( - "fatal flex scanner internal error--end of buffer missed" ); - - if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) - { /* Don't try to fill the buffer, so this is an EOF. */ - if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) - { - /* We matched a single character, the EOB, so - * treat this as a final EOF. - */ - return EOB_ACT_END_OF_FILE; - } - - else - { - /* We matched some text prior to the EOB, first - * process it. - */ - return EOB_ACT_LAST_MATCH; - } - } - - /* Try to read more data. */ - - /* First move last chars to start of buffer. */ - number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); - - for ( i = 0; i < number_to_move; ++i ) - *(dest++) = *(source++); - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) - /* don't do the read, it's not guaranteed to return an EOF, - * just force an EOF - */ - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; - - else - { - int num_to_read = - YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; - - while ( num_to_read <= 0 ) - { /* Not enough room in the buffer - grow it. */ - - /* just a shorter name for the current buffer */ - YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; - - int yy_c_buf_p_offset = - (int) ((yy_c_buf_p) - b->yy_ch_buf); - - if ( b->yy_is_our_buffer ) - { - int new_size = b->yy_buf_size * 2; - - if ( new_size <= 0 ) - b->yy_buf_size += b->yy_buf_size / 8; - else - b->yy_buf_size *= 2; - - b->yy_ch_buf = (char *) - /* Include room in for 2 EOB chars. */ - yyrealloc( (void *) b->yy_ch_buf, - (yy_size_t) (b->yy_buf_size + 2) ); - } - else - /* Can't grow it, we don't own it. */ - b->yy_ch_buf = NULL; - - if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( - "fatal error - scanner input buffer overflow" ); - - (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; - - num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - - number_to_move - 1; - - } - - if ( num_to_read > YY_READ_BUF_SIZE ) - num_to_read = YY_READ_BUF_SIZE; - - /* Read in more data. */ - YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), - (yy_n_chars), num_to_read ); - - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - if ( (yy_n_chars) == 0 ) - { - if ( number_to_move == YY_MORE_ADJ ) - { - ret_val = EOB_ACT_END_OF_FILE; - yyrestart( yyin ); - } - - else - { - ret_val = EOB_ACT_LAST_MATCH; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = - YY_BUFFER_EOF_PENDING; - } - } - - else - ret_val = EOB_ACT_CONTINUE_SCAN; - - if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { - /* Extend the array by 50%, plus the number we really need. */ - int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( - (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); - if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); - /* "- 2" to take care of EOB's */ - YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); - } - - (yy_n_chars) += number_to_move; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; - - (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; - - return ret_val; -} - -/* yy_get_previous_state - get the state just before the EOB char was reached */ - - static yy_state_type yy_get_previous_state (void) -{ - yy_state_type yy_current_state; - char *yy_cp; - - yy_current_state = (yy_start); - - for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) - { - YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 147 ) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - } - - return yy_current_state; -} - -/* yy_try_NUL_trans - try to make a transition on the NUL character - * - * synopsis - * next_state = yy_try_NUL_trans( current_state ); - */ - static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) -{ - int yy_is_jam; - char *yy_cp = (yy_c_buf_p); - - YY_CHAR yy_c = 1; - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 147 ) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 146); - - return yy_is_jam ? 0 : yy_current_state; -} - -#ifndef YY_NO_UNPUT - - static void yyunput (int c, char * yy_bp ) -{ - char *yy_cp; - - yy_cp = (yy_c_buf_p); - - /* undo effects of setting up yytext */ - *yy_cp = (yy_hold_char); - - if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) - { /* need to shift things up to make room */ - /* +2 for EOB chars. */ - int number_to_move = (yy_n_chars) + 2; - char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ - YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; - char *source = - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; - - while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) - *--dest = *--source; - - yy_cp += (int) (dest - source); - yy_bp += (int) (dest - source); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = - (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; - - if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) - YY_FATAL_ERROR( "flex scanner push-back overflow" ); - } - - *--yy_cp = (char) c; - - (yytext_ptr) = yy_bp; - (yy_hold_char) = *yy_cp; - (yy_c_buf_p) = yy_cp; -} - -#endif - -#ifndef YY_NO_INPUT -#ifdef __cplusplus - static int yyinput (void) -#else - static int input (void) -#endif - -{ - int c; - - *(yy_c_buf_p) = (yy_hold_char); - - if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) - { - /* yy_c_buf_p now points to the character we want to return. - * If this occurs *before* the EOB characters, then it's a - * valid NUL; if not, then we've hit the end of the buffer. - */ - if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) - /* This was really a NUL. */ - *(yy_c_buf_p) = '\0'; - - else - { /* need more input */ - int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); - ++(yy_c_buf_p); - - switch ( yy_get_next_buffer( ) ) - { - case EOB_ACT_LAST_MATCH: - /* This happens because yy_g_n_b() - * sees that we've accumulated a - * token and flags that we need to - * try matching the token before - * proceeding. But for input(), - * there's no matching to consider. - * So convert the EOB_ACT_LAST_MATCH - * to EOB_ACT_END_OF_FILE. - */ - - /* Reset buffer status. */ - yyrestart( yyin ); - - /*FALLTHROUGH*/ - - case EOB_ACT_END_OF_FILE: - { - if ( yywrap( ) ) - return 0; - - if ( ! (yy_did_buffer_switch_on_eof) ) - YY_NEW_FILE; -#ifdef __cplusplus - return yyinput(); -#else - return input(); -#endif - } - - case EOB_ACT_CONTINUE_SCAN: - (yy_c_buf_p) = (yytext_ptr) + offset; - break; - } - } - } - - c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ - *(yy_c_buf_p) = '\0'; /* preserve yytext */ - (yy_hold_char) = *++(yy_c_buf_p); - - return c; -} -#endif /* ifndef YY_NO_INPUT */ - -/** Immediately switch to a different input stream. - * @param input_file A readable stream. - * - * @note This function does not reset the start condition to @c INITIAL . - */ - void yyrestart (FILE * input_file ) -{ - - if ( ! YY_CURRENT_BUFFER ){ - yyensure_buffer_stack (); - YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer( yyin, YY_BUF_SIZE ); - } - - yy_init_buffer( YY_CURRENT_BUFFER, input_file ); - yy_load_buffer_state( ); -} - -/** Switch to a different input buffer. - * @param new_buffer The new input buffer. - * - */ - void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) -{ - - /* TODO. We should be able to replace this entire function body - * with - * yypop_buffer_state(); - * yypush_buffer_state(new_buffer); - */ - yyensure_buffer_stack (); - if ( YY_CURRENT_BUFFER == new_buffer ) - return; - - if ( YY_CURRENT_BUFFER ) - { - /* Flush out information for old buffer. */ - *(yy_c_buf_p) = (yy_hold_char); - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - YY_CURRENT_BUFFER_LVALUE = new_buffer; - yy_load_buffer_state( ); - - /* We don't actually know whether we did this switch during - * EOF (yywrap()) processing, but the only time this flag - * is looked at is after yywrap() is called, so it's safe - * to go ahead and always set it. - */ - (yy_did_buffer_switch_on_eof) = 1; -} - -static void yy_load_buffer_state (void) -{ - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; - yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; - (yy_hold_char) = *(yy_c_buf_p); -} - -/** Allocate and initialize an input buffer state. - * @param file A readable stream. - * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. - * - * @return the allocated buffer state. - */ - YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) -{ - YY_BUFFER_STATE b; - - b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); - if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); - - b->yy_buf_size = size; - - /* yy_ch_buf has to be 2 characters longer than the size given because - * we need to put in 2 end-of-buffer characters. - */ - b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); - if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); - - b->yy_is_our_buffer = 1; - - yy_init_buffer( b, file ); - - return b; -} - -/** Destroy the buffer. - * @param b a buffer created with yy_create_buffer() - * - */ - void yy_delete_buffer (YY_BUFFER_STATE b ) -{ - - if ( ! b ) - return; - - if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ - YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; - - if ( b->yy_is_our_buffer ) - yyfree( (void *) b->yy_ch_buf ); - - yyfree( (void *) b ); -} - -/* Initializes or reinitializes a buffer. - * This function is sometimes called more than once on the same buffer, - * such as during a yyrestart() or at EOF. - */ - static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) - -{ - int oerrno = errno; - - yy_flush_buffer( b ); - - b->yy_input_file = file; - b->yy_fill_buffer = 1; - - /* If b is the current buffer, then yy_init_buffer was _probably_ - * called from yyrestart() or through yy_get_next_buffer. - * In that case, we don't want to reset the lineno or column. - */ - if (b != YY_CURRENT_BUFFER){ - b->yy_bs_lineno = 1; - b->yy_bs_column = 0; - } - - b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; - - errno = oerrno; -} - -/** Discard all buffered characters. On the next scan, YY_INPUT will be called. - * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. - * - */ - void yy_flush_buffer (YY_BUFFER_STATE b ) -{ - if ( ! b ) - return; - - b->yy_n_chars = 0; - - /* We always need two end-of-buffer characters. The first causes - * a transition to the end-of-buffer state. The second causes - * a jam in that state. - */ - b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; - b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; - - b->yy_buf_pos = &b->yy_ch_buf[0]; - - b->yy_at_bol = 1; - b->yy_buffer_status = YY_BUFFER_NEW; - - if ( b == YY_CURRENT_BUFFER ) - yy_load_buffer_state( ); -} - -/** Pushes the new state onto the stack. The new state becomes - * the current state. This function will allocate the stack - * if necessary. - * @param new_buffer The new state. - * - */ -void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) -{ - if (new_buffer == NULL) - return; - - yyensure_buffer_stack(); - - /* This block is copied from yy_switch_to_buffer. */ - if ( YY_CURRENT_BUFFER ) - { - /* Flush out information for old buffer. */ - *(yy_c_buf_p) = (yy_hold_char); - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - /* Only push if top exists. Otherwise, replace top. */ - if (YY_CURRENT_BUFFER) - (yy_buffer_stack_top)++; - YY_CURRENT_BUFFER_LVALUE = new_buffer; - - /* copied from yy_switch_to_buffer. */ - yy_load_buffer_state( ); - (yy_did_buffer_switch_on_eof) = 1; -} - -/** Removes and deletes the top of the stack, if present. - * The next element becomes the new top. - * - */ -void yypop_buffer_state (void) -{ - if (!YY_CURRENT_BUFFER) - return; - - yy_delete_buffer(YY_CURRENT_BUFFER ); - YY_CURRENT_BUFFER_LVALUE = NULL; - if ((yy_buffer_stack_top) > 0) - --(yy_buffer_stack_top); - - if (YY_CURRENT_BUFFER) { - yy_load_buffer_state( ); - (yy_did_buffer_switch_on_eof) = 1; - } -} - -/* Allocates the stack if it does not exist. - * Guarantees space for at least one push. - */ -static void yyensure_buffer_stack (void) -{ - yy_size_t num_to_alloc; - - if (!(yy_buffer_stack)) { - - /* First allocation is just for 2 elements, since we don't know if this - * scanner will even need a stack. We use 2 instead of 1 to avoid an - * immediate realloc on the next call. - */ - num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ - (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc - (num_to_alloc * sizeof(struct yy_buffer_state*) - ); - if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - - memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); - - (yy_buffer_stack_max) = num_to_alloc; - (yy_buffer_stack_top) = 0; - return; - } - - if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ - - /* Increase the buffer to prepare for a possible push. */ - yy_size_t grow_size = 8 /* arbitrary grow size */; - - num_to_alloc = (yy_buffer_stack_max) + grow_size; - (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc - ((yy_buffer_stack), - num_to_alloc * sizeof(struct yy_buffer_state*) - ); - if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - - /* zero only the new slots.*/ - memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); - (yy_buffer_stack_max) = num_to_alloc; - } -} - -/** Setup the input buffer state to scan directly from a user-specified character buffer. - * @param base the character buffer - * @param size the size in bytes of the character buffer - * - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) -{ - YY_BUFFER_STATE b; - - if ( size < 2 || - base[size-2] != YY_END_OF_BUFFER_CHAR || - base[size-1] != YY_END_OF_BUFFER_CHAR ) - /* They forgot to leave room for the EOB's. */ - return NULL; - - b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); - if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); - - b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ - b->yy_buf_pos = b->yy_ch_buf = base; - b->yy_is_our_buffer = 0; - b->yy_input_file = NULL; - b->yy_n_chars = b->yy_buf_size; - b->yy_is_interactive = 0; - b->yy_at_bol = 1; - b->yy_fill_buffer = 0; - b->yy_buffer_status = YY_BUFFER_NEW; - - yy_switch_to_buffer( b ); - - return b; -} - -/** Setup the input buffer state to scan a string. The next call to yylex() will - * scan from a @e copy of @a str. - * @param yystr a NUL-terminated string to scan - * - * @return the newly allocated buffer state object. - * @note If you want to scan bytes that may contain NUL values, then use - * yy_scan_bytes() instead. - */ -YY_BUFFER_STATE yy_scan_string (const char * yystr ) -{ - - return yy_scan_bytes( yystr, (int) strlen(yystr) ); -} - -/** Setup the input buffer state to scan the given bytes. The next call to yylex() will - * scan from a @e copy of @a bytes. - * @param yybytes the byte buffer to scan - * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. - * - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) -{ - YY_BUFFER_STATE b; - char *buf; - yy_size_t n; - int i; - - /* Get memory for full buffer, including space for trailing EOB's. */ - n = (yy_size_t) (_yybytes_len + 2); - buf = (char *) yyalloc( n ); - if ( ! buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); - - for ( i = 0; i < _yybytes_len; ++i ) - buf[i] = yybytes[i]; - - buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - - b = yy_scan_buffer( buf, n ); - if ( ! b ) - YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); - - /* It's okay to grow etc. this buffer, and we should throw it - * away when we're done. - */ - b->yy_is_our_buffer = 1; - - return b; -} - -#ifndef YY_EXIT_FAILURE -#define YY_EXIT_FAILURE 2 -#endif - -static void yynoreturn yy_fatal_error (const char* msg ) -{ - fprintf( stderr, "%s\n", msg ); - exit( YY_EXIT_FAILURE ); -} - -/* Redefine yyless() so it works in section 3 code. */ - -#undef yyless -#define yyless(n) \ - 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 ) - -/* Accessor methods (get/set functions) to struct members. */ - -/** Get the current line number. - * - */ -int yyget_lineno (void) -{ - - return yylineno; -} - -/** Get the input stream. - * - */ -FILE *yyget_in (void) -{ - return yyin; -} - -/** Get the output stream. - * - */ -FILE *yyget_out (void) -{ - return yyout; -} - -/** Get the length of the current token. - * - */ -int yyget_leng (void) -{ - return yyleng; -} - -/** Get the current token. - * - */ - -char *yyget_text (void) -{ - return yytext; -} - -/** Set the current line number. - * @param _line_number line number - * - */ -void yyset_lineno (int _line_number ) -{ - - yylineno = _line_number; -} - -/** Set the input stream. This does not discard the current - * input buffer. - * @param _in_str A readable stream. - * - * @see yy_switch_to_buffer - */ -void yyset_in (FILE * _in_str ) -{ - yyin = _in_str ; -} - -void yyset_out (FILE * _out_str ) -{ - yyout = _out_str ; -} - -int yyget_debug (void) -{ - return yy_flex_debug; -} - -void yyset_debug (int _bdebug ) -{ - yy_flex_debug = _bdebug ; -} - -static int yy_init_globals (void) -{ - /* Initialization is the same as for the non-reentrant scanner. - * This function is called from yylex_destroy(), so don't allocate here. - */ - - (yy_buffer_stack) = NULL; - (yy_buffer_stack_top) = 0; - (yy_buffer_stack_max) = 0; - (yy_c_buf_p) = NULL; - (yy_init) = 0; - (yy_start) = 0; - -/* Defined in main.c */ -#ifdef YY_STDINIT - yyin = stdin; - yyout = stdout; -#else - yyin = NULL; - yyout = NULL; -#endif - - /* For future reference: Set errno on error, since we are called by - * yylex_init() - */ - return 0; -} - -/* yylex_destroy is for both reentrant and non-reentrant scanners. */ -int yylex_destroy (void) -{ - - /* Pop the buffer stack, destroying each element. */ - while(YY_CURRENT_BUFFER){ - yy_delete_buffer( YY_CURRENT_BUFFER ); - YY_CURRENT_BUFFER_LVALUE = NULL; - yypop_buffer_state(); - } - - /* Destroy the stack itself. */ - yyfree((yy_buffer_stack) ); - (yy_buffer_stack) = NULL; - - /* Reset the globals. This is important in a non-reentrant scanner so the next time - * yylex() is called, initialization will occur. */ - yy_init_globals( ); - - return 0; -} - -/* - * Internal utility routines. - */ - -#ifndef yytext_ptr -static void yy_flex_strncpy (char* s1, const char * s2, int n ) -{ - - int i; - for ( i = 0; i < n; ++i ) - s1[i] = s2[i]; -} -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen (const char * s ) -{ - int n; - for ( n = 0; s[n]; ++n ) - ; - - return n; -} -#endif - -void *yyalloc (yy_size_t size ) -{ - return malloc(size); -} - -void *yyrealloc (void * ptr, yy_size_t size ) -{ - - /* The cast to (char *) in the following accommodates both - * implementations that use char* generic pointers, and those - * that use void* generic pointers. It works with the latter - * because both ANSI C and C++ allow castless assignment from - * any pointer type to void*, and deal with argument conversions - * as though doing an assignment. - */ - return realloc(ptr, size); -} - -void yyfree (void * ptr ) -{ - free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ -} - -#define YYTABLES_NAME "yytables" - -#line 90 "lexicalStructure.lex" - - diff --git a/parser b/parser deleted file mode 100755 index 02e2648389b3dc49b093d9cc710c25095f792e19..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 40856 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 Gmi-^SJbnZK From 2695334db91d5df680d6128aa91821b783bcfc8c Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Fri, 28 Feb 2025 15:42:43 -0500 Subject: [PATCH 17/19] added print statements to gramamr rules to check for debugging --- grammar.y | 65 ++++++++++++++++++++++++++++++++++++++++-------------- parser | Bin 0 -> 40984 bytes 2 files changed, 49 insertions(+), 16 deletions(-) create mode 100755 parser diff --git a/grammar.y b/grammar.y index e10b99f..bf8e417 100644 --- a/grammar.y +++ b/grammar.y @@ -39,7 +39,7 @@ %left ASSIGN %token ID 101 -%token T_INTEGER +%token T_INTEGER 201 %token T_ADDRESS 202 %token T_BOOLEAN 203 %token T_CHARACTER 204 @@ -120,20 +120,51 @@ idlist: ; sblock: - L_BRACE /*{st = CreateScope(st,1,1);}*/ statement_list /*{st = getParent(st);}*/ R_BRACE - | L_BRACE /*{st = CreateScope(st,1,1);}*/ dblock statement_list /*{st = getParent(st);}*/ R_BRACE + L_BRACE {st = CreateScope(st,1,1);} statement_list {st = getParent(st);} R_BRACE + | L_BRACE {st = CreateScope(st,1,1);} dblock statement_list {st = getParent(st);} R_BRACE ; dblock: L_BRACKET declaration_list R_BRACKET; declaration_list: - declaration /*{CreateEntry(st,cur_type,cur_value);}*/ SEMI_COLON declaration_list - | declaration //{CreateEntry(st,cur_type,cur_value);} + declaration + {printf( + "declaration list a rule encountered"); + //CreateEntry(st,cur_type,cur_value); + } + SEMI_COLON declaration_list + | declaration + {printf( + "declaration rule b encountered"); + //CreateEntry(st,cur_type,cur_value); + } ; declaration: - ID COLON ID //{cur_value = strdup($1);cur_type = strdup($3);} + ID COLON ID { + printf("declaration rule encountered"); +// if(cur_value != NULL){ +// char* delete1 = cur_value; + printf("delete1 var assigned to cur_value"); +// free(delete1); + printf("delete1 var freed"); +// } +// if(cur_type != NULL){ +// char* delete2 = cur_type; +// free(delete2);} +// int len = strlen($1); + printf("length determined"); +// cur_value = malloc(len + 1); + printf("space allocated"); +// strcpy(cur_value, $1); + printf("string copied over"); + +// len = strlen($3); +// cur_type = malloc(len + 1); +// strcpy(cur_type, $3); +// printf("value var is %s type var is %s\n",cur_value,cur_type); + } | types COLON ID ; @@ -220,25 +251,27 @@ types: %% void yyerror(const char *err) { - fprintf(stderr, "ERROR: %s at token %s at line number %d,column number %d\n", err,yytext,line_number,column_number); + // fprintf(stderr, "ERROR: %s at token %s at line number %d,column number %d\n", err,yytext,line_number,column_number); } int main() { - //cur_value = NULL; - //cur_type = NULL; + char *str = strdup("taco"); + cur_value = NULL; + cur_type = NULL; token_tracker = 1; st=CreateScope(NULL,1,1); - int a; - while ((a = yyparse()) != EOF){ - token_tracker++; + //int a; + yyparse(); + //while ((a = yyparse() != EOF){ + // token_tracker++; //printf("%d = a: yytext = %s: yychar = %d, token number: %d\n", a, yytext, yychar,token_tracker); - if(yytext[0] == '\n'){ + //if(yytext[0] == '\n'){ FILE* f = fdopen(1,"w"); print_symbol_table(getAncestor(st),f); fclose(f); - break; - } - } + // break; + //} + //} return 0; } diff --git a/parser b/parser new file mode 100755 index 0000000000000000000000000000000000000000..414407a4dbe4de88595d639d6eff1860f4fbd916 GIT binary patch literal 40984 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 Date: Fri, 28 Feb 2025 17:42:47 -0500 Subject: [PATCH 18/19] Updated header --- symbol_table.c | 261 +++++++++++++++++++++++-------------------------- symbol_table.h | 55 ++++++----- 2 files changed, 157 insertions(+), 159 deletions(-) diff --git a/symbol_table.c b/symbol_table.c index 1a2e375..48a7a42 100644 --- a/symbol_table.c +++ b/symbol_table.c @@ -1,156 +1,143 @@ +#include "symbol_table.h" + #include #include #include -#include "symbol_table.h" - -SymbolTable* CreateScope(SymbolTable* ParentScope, int Line, int Column){ - SymbolTable* table = (SymbolTable*)malloc(sizeof(SymbolTable)); - table->Line_Number = Line; - table->Column_Number = Column; - table->Parent_Scope = ParentScope; - table->Children_Scope = NULL; - table->entries = NULL; - if(ParentScope != NULL){ - if(ParentScope->Children_Scope == NULL){ - ListOfTable* newEntry = (ListOfTable*)malloc(sizeof(ListOfTable)); - newEntry->next = NULL; - //newEntry->prev = NULL; - newEntry->table = table; - ParentScope->Children_Scope = newEntry; - } else{ - ListOfTable* newEntry = (ListOfTable*)malloc(sizeof(ListOfTable)); - //newEntry->prev = NULL; - newEntry->table= table; - ListOfTable* oldEntry = ParentScope->Children_Scope; - ParentScope->Children_Scope = newEntry; - newEntry->next = oldEntry; - } - } - return table; - } - - -TableNode* CreateEntry(SymbolTable* table, char* typeOf, char* id){ - TableNode* newEntry = (TableNode*)malloc(sizeof(TableNode)); - newEntry->theType = typeOf; - newEntry->theName = id; - if(table->entries == NULL){ - table->entries = newEntry; - return newEntry; - } else{ - TableNode* oldEntry = table->entries; - table->entries = newEntry; - newEntry->next = oldEntry; - return newEntry; - } -} -TableNode * table_lookup(SymbolTable * table, char * x){ - TableNode * entrie = table->entries; - for(; entrie != NULL; entrie = entrie->next){ - if (!strcmp(entrie->theName, x)){ - return entrie; - } - } - return NULL; -} -TableNode * look_up(SymbolTable * table, char * x){ - if(table == NULL){ - return NULL; - } - TableNode * ret = table_lookup(table, x); - if (ret != NULL){ - return ret; - } - return look_up(table->Parent_Scope, x); +SymbolTable* CreateScope(SymbolTable* ParentScope, int Line, int Column) { + SymbolTable* table = (SymbolTable*)malloc(sizeof(SymbolTable)); + table->Line_Number = Line; + table->Column_Number = Column; + table->Parent_Scope = ParentScope; + table->Children_Scope = NULL; + table->entries = NULL; + if (ParentScope != NULL) { + if (ParentScope->Children_Scope == NULL) { + ListOfTable* newEntry = (ListOfTable*)malloc(sizeof(ListOfTable)); + newEntry->next = NULL; + // newEntry->prev = NULL; + newEntry->table = table; + ParentScope->Children_Scope = newEntry; + } else { + ListOfTable* newEntry = (ListOfTable*)malloc(sizeof(ListOfTable)); + // newEntry->prev = NULL; + newEntry->table = table; + ListOfTable* oldEntry = ParentScope->Children_Scope; + ParentScope->Children_Scope = newEntry; + newEntry->next = oldEntry; + } + } + return table; } -SymbolTable * getAncestor(SymbolTable * table){ - if(table->Parent_Scope == NULL){ - //if table has no parent, return itself - return table; - } else { - //call function recursively to grab ancestor - return getAncestor(table->Parent_Scope); - } +TableNode* CreateEntry(SymbolTable* table, char* typeOf, char* id) { + TableNode* newEntry = (TableNode*)malloc(sizeof(TableNode)); + newEntry->theType = typeOf; + newEntry->theName = id; + if (table->entries == NULL) { + table->entries = newEntry; + return newEntry; + } else { + TableNode* oldEntry = table->entries; + table->entries = newEntry; + newEntry->next = oldEntry; + return newEntry; + } } -void print_symbol_table(SymbolTable *table, FILE *file_ptr){ - if(table->Parent_Scope == NULL){ - fprintf(file_ptr, "%-17s: %-6s : %-6s : %-21s: %-28s\n", "NAME", "SCOPE", "PARENT", "TYPE", "Extra annotation"); - } - TableNode * entrie = table->entries; - fprintf(file_ptr, "-----------------:--------:--------:----------------------:-----------------------------\n"); - int parant_scope = 0; - int current_scope = 0; - if(table->Parent_Scope != NULL){ - parant_scope = table->Parent_Scope->Line_Number*1000 + table->Parent_Scope->Column_Number; - current_scope = table->Line_Number*1000 + table->Column_Number; - } else { - current_scope = 1001; - } - - for(; entrie != NULL; entrie = entrie->next){ - if (parant_scope == 0){ - fprintf(file_ptr, "%-17s: %06d : : %-21s: %-28s\n", - entrie->theName, current_scope, - entrie->theType, "Extra annotation"); - } else { - fprintf(file_ptr, "%-17s: %06d : %06d : %-21s: %-28s\n", - entrie->theName, current_scope, parant_scope, - entrie->theType, "Extra annotation"); - } - } - if (table->Children_Scope != NULL){ - ListOfTable* node = table->Children_Scope; - for(; node != NULL; node = node->next){ - print_symbol_table(node->table, file_ptr); - } - } - if (table->Parent_Scope == NULL) { - fprintf(file_ptr, "-----------------:--------:--------:----------------------:-----------------------------\n"); - } +TableNode* table_lookup(SymbolTable* table, char* x) { + TableNode* entrie = table->entries; + for (; entrie != NULL; entrie = entrie->next) { + if (!strcmp(entrie->theName, x)) { + return entrie; + } + } + return NULL; +} +TableNode* look_up(SymbolTable* table, char* x) { + if (table == NULL) { + return NULL; + } + TableNode* ret = table_lookup(table, x); + if (ret != NULL) { + return ret; + } + return look_up(table->Parent_Scope, x); } -SymbolTable * getParent(SymbolTable* st){ - return st->Parent_Scope; - } +void print_symbol_table(SymbolTable* table, FILE* file_ptr) { + if (table->Parent_Scope == NULL) { + fprintf(file_ptr, "%-17s: %-6s : %-6s : %-21s: %-28s\n", "NAME", "SCOPE", + "PARENT", "TYPE", "Extra annotation"); + } + TableNode* entrie = table->entries; + fprintf(file_ptr, + "-----------------:--------:--------:----------------------:---------" + "--------------------\n"); + int parant_scope = 0; + int current_scope = 0; + if (table->Parent_Scope != NULL) { + parant_scope = table->Parent_Scope->Line_Number * 1000 + + table->Parent_Scope->Column_Number; + current_scope = table->Line_Number * 1000 + table->Column_Number; + } else { + current_scope = 1001; + } -ListOfTable * getChildren(SymbolTable* st){ - return st->Children_Scope; - } -SymbolTable * getFirstChild(ListOfTable * lt){ - return lt->table; - } -ListOfTable * getRestOfChildren(ListOfTable * lt){ - return lt->next; - } -TableNode * getFirstEntry(SymbolTable * st){ - return st->entries; - } -TableNode * getNextEntry(TableNode * tn){ - return tn->next; - } -char * getType(TableNode * tn){ - return tn->theType; - } -char * getName(TableNode * tn){ - return tn->theName; - } -int getLine(SymbolTable * st){ - return st->Line_Number; - } -int getColumn(SymbolTable *st){ - return st->Column_Number; - } -//uncomment the below main function along with the headers above for a simple standalone test of table and entry creation + for (; entrie != NULL; entrie = entrie->next) { + if (parant_scope == 0) { + fprintf(file_ptr, "%-17s: %06d : : %-21s: %-28s\n", + entrie->theName, current_scope, entrie->theType, + "Extra annotation"); + } else { + fprintf(file_ptr, "%-17s: %06d : %06d : %-21s: %-28s\n", entrie->theName, + current_scope, parant_scope, entrie->theType, "Extra annotation"); + } + } + if (table->Children_Scope != NULL) { + ListOfTable* node = table->Children_Scope; + for (; node != NULL; node = node->next) { + print_symbol_table(node->table, file_ptr); + } + } + if (table->Parent_Scope == NULL) { + fprintf(file_ptr, + "-----------------:--------:--------:----------------------:-------" + "----------------------\n"); + } +} + +SymbolTable* getAncestor(SymbolTable* table) { + if (table->Parent_Scope == NULL) { + // if table has no parent, return itself + return table; + } else { + // call function recursively to grab ancestor + return getAncestor(table->Parent_Scope); + } +} + +SymbolTable* getParent(SymbolTable* st) { return st->Parent_Scope; } + +ListOfTable* getChildren(SymbolTable* st) { return st->Children_Scope; } +SymbolTable* getFirstChild(ListOfTable* lt) { return lt->table; } +ListOfTable* getRestOfChildren(ListOfTable* lt) { return lt->next; } +TableNode* getFirstEntry(SymbolTable* st) { return st->entries; } +TableNode* getNextEntry(TableNode* tn) { return tn->next; } +char* getType(TableNode* tn) { return tn->theType; } +char* getName(TableNode* tn) { return tn->theName; } +int getLine(SymbolTable* st) { return st->Line_Number; } +int getColumn(SymbolTable* st) { return st->Column_Number; } +// uncomment the below main function along with the headers above for a simple +// standalone test of table and entry creation /* int main(){ char* String = "STRING"; char* X = "X"; SymbolTable* Second = CreateScope(NULL, 2,2); - printf("Line number is %d, Column number of scope is %d\n",Second->Line_Number,Second->Column_Number); - TableNode* First_Entry = CreateEntry(Second,String,X); + printf("Line number is %d, Column number of scope is +%d\n",Second->Line_Number,Second->Column_Number); TableNode* First_Entry = +CreateEntry(Second,String,X); printf("The type of the first entry is %s\n",First_Entry->theType); return 0; diff --git a/symbol_table.h b/symbol_table.h index 0d30f59..0ef5c8a 100644 --- a/symbol_table.h +++ b/symbol_table.h @@ -3,30 +3,41 @@ #include #include -typedef struct ListOfTable{ - struct SymbolTable* table; - //struct ListOfTable* prev; - struct ListOfTable* next; +typedef struct ListOfTable { + struct SymbolTable* table; + // struct ListOfTable* prev; + struct ListOfTable* next; -}ListOfTable; +} ListOfTable; -typedef struct TableNode{ - char* theType; - char* theName; - struct TableNode* next; -}TableNode; +typedef struct TableNode { + char* theType; + char* theName; + struct TableNode* next; +} TableNode; -typedef struct SymbolTable{ - TableNode* entries; - struct SymbolTable* Parent_Scope; - struct ListOfTable* Children_Scope; - int Line_Number; - int Column_Number; -}SymbolTable; +typedef struct SymbolTable { + TableNode* entries; + struct SymbolTable* Parent_Scope; + struct ListOfTable* Children_Scope; + int Line_Number; + int Column_Number; +} SymbolTable; - -TableNode* CreateEntry(SymbolTable* table, char* typeOf, char* id); SymbolTable* CreateScope(SymbolTable* ParentScope, int Line, int Column); -TableNode * table_lookup(SymbolTable * table, char * x); -TableNode * look_up(SymbolTable * table, char * x); -void print_symbol_table(SymbolTable *table, FILE *file_ptr); +TableNode* CreateEntry(SymbolTable* table, char* typeOf, char* id); +TableNode* table_lookup(SymbolTable* table, char* x); +TableNode* look_up(SymbolTable* table, char* x); +void print_symbol_table(SymbolTable* table, FILE* file_ptr); + +SymbolTable* getAncestor(SymbolTable* table); +SymbolTable* getParent(SymbolTable* st); +ListOfTable* getChildren(SymbolTable* st); +SymbolTable* getFirstChild(ListOfTable* lt); +ListOfTable* getRestOfChildren(ListOfTable* lt); +TableNode* getFirstEntry(SymbolTable* st); +TableNode* getNextEntry(TableNode* tn); +char* getType(TableNode* tn); +char* getName(TableNode* tn); +int getLine(SymbolTable* st); +int getColumn(SymbolTable* st); \ No newline at end of file From 63212a3d63e85a97ca1f78f28274337cfdaff1d4 Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Fri, 28 Feb 2025 18:16:44 -0500 Subject: [PATCH 19/19] entries are working but not freeing memory so potential for leaks --- .Makefile.swp | Bin 12288 -> 0 bytes grammar.y | 28 +++++++++++++++------------- lexicalStructure.lex | 4 +++- parser | Bin 40984 -> 0 bytes 4 files changed, 18 insertions(+), 14 deletions(-) delete mode 100644 .Makefile.swp delete mode 100755 parser diff --git a/.Makefile.swp b/.Makefile.swp deleted file mode 100644 index 731dce035acfa5772ee102a56adbe2804c3e8404..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 12288 zcmeI2y>HV%7>5s72$T;&2PBpQiqryjN-0uhsY7W?RjEvTRst2rxqMK^w$2wIs`ywK zkeFD2e}KZk!hi$=A3H2;?0{7M02UbdonxnU;?M|*0rW1P*w1(6@Z-{^FZcJdpfEbBo7a0eLYCIc(eazQ!@T3#VVHM9F*iV<0Uy9y@B%D@$KVdQ z1TKO}V1Oea2R4J1?Kls-2T#Fma0{FV2f+aNv5m1e;5B##9)XA81}K9PxC|`N2fp?p zA3Ov#Fai3(x2Q6Bcfk_yz&w}&k&l0H zJ!#5hfDDiUGC&5%z~3{FlQnLX_#rb?EdIMJ?OM&2rm_oWC9Ba%8V{MuUrY{4uDHIM zKQK6bVR|Tu=}@C#t~t?Xjw@`>!hbntzM0I8P;oP_M5w~(ePK~FuKBVUnzkEM?6yn; zW2e*oK*;Dx%g%hA+tIxgw!08@y)cq}N@_NLo~|GI>|ubgS_@n;S5+v(%_zE~;N}Ul zo;m|(Jq+OEiBuWXJ*Su4-^)yy>Ap@KQ!WcnS9iu=6kdw&%T8+2PXiLl-C7qM*+hNV9>051q^kD^MW)#qx zhv6huIPq+Ck8!vatMGUW)t#N3o4ycPXjMHhsGC@F9MxNOZ1=R1bw|~uFcD%bS(Gdv z%@L!?&QECHsZ~kVNALSi*6LtQ0$YYcuBuL*!{X?gp;K{=uca84TjRWWQLy-mvBnve bTDLbhdK9V;P)}!pT8s{ASFG7t*>Tt}gkE>x diff --git a/grammar.y b/grammar.y index bf8e417..2302167 100644 --- a/grammar.y +++ b/grammar.y @@ -10,8 +10,8 @@ extern char* yytext; extern int yychar; SymbolTable * st; - char* cur_value; - char* cur_type; + //char* cur_value; + //char* cur_type; int token_tracker; extern int line_number; extern int column_number; @@ -120,8 +120,8 @@ idlist: ; sblock: - L_BRACE {st = CreateScope(st,1,1);} statement_list {st = getParent(st);} R_BRACE - | L_BRACE {st = CreateScope(st,1,1);} dblock statement_list {st = getParent(st);} R_BRACE + L_BRACE {st = CreateScope(st,2,2);} statement_list {st = getParent(st);} R_BRACE + | L_BRACE {st = CreateScope(st,2,2);} dblock statement_list {st = getParent(st);} R_BRACE ; dblock: @@ -143,22 +143,24 @@ declaration_list: declaration: ID COLON ID { - printf("declaration rule encountered"); + + CreateEntry(st,strdup($1),strdup($3)); +// printf("declaration rule encountered"); // if(cur_value != NULL){ // char* delete1 = cur_value; - printf("delete1 var assigned to cur_value"); +// printf("delete1 var assigned to cur_value"); // free(delete1); - printf("delete1 var freed"); +// printf("delete1 var freed"); // } // if(cur_type != NULL){ // char* delete2 = cur_type; // free(delete2);} // int len = strlen($1); - printf("length determined"); +// printf("length determined"); // cur_value = malloc(len + 1); - printf("space allocated"); +// printf("space allocated"); // strcpy(cur_value, $1); - printf("string copied over"); +// printf("string copied over"); // len = strlen($3); // cur_type = malloc(len + 1); @@ -255,9 +257,9 @@ void yyerror(const char *err) { } int main() { - char *str = strdup("taco"); - cur_value = NULL; - cur_type = NULL; + //char *str = strdup("taco"); + //cur_value = NULL; + //cur_type = NULL; token_tracker = 1; st=CreateScope(NULL,1,1); diff --git a/lexicalStructure.lex b/lexicalStructure.lex index 3bd0332..5f1f8ec 100644 --- a/lexicalStructure.lex +++ b/lexicalStructure.lex @@ -12,6 +12,8 @@ #ifndef DEBUG #define DEBUG 0 #endif + + %} STARCOM [^\*]|\*+[^\)\*]+ @@ -79,7 +81,7 @@ SCHAR \\n|\\t|\\\"|[^\"\n\\] "false" {if(DEBUG) {printf( "C_FALSE: %s (%d)\n", yytext, C_FALSE);} else {return C_FALSE;}} "null" {if(DEBUG) {printf( "C_NULL: %s (%d)\n", yytext, C_NULL);} else {return C_NULL;}} -{ID} {if(DEBUG) {printf( "ID: %s (%d)\n", yytext, ID);} else {return ID;}} +{ID} {if(DEBUG) {printf( "ID: %s (%d)\n", yytext, ID);} else {yylval.words = strdup(yytext); return ID;}} \n {line_number++; column_number = 1;} \t {column_number++;} diff --git a/parser b/parser deleted file mode 100755 index 414407a4dbe4de88595d639d6eff1860f4fbd916..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 40984 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