From 90407da44c7e5e3a456292f4f73b9d228dcfcc39 Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Thu, 13 Feb 2025 19:00:43 -0500 Subject: [PATCH] ran make file to display all .tok files --- Makefile | 5 +- flex.h | 477 +++++++++ flex.o | Bin 0 -> 27880 bytes lex.yy.c | 2043 +++++++++++++++++++++++++++++++++++++ lexicalStructure.lex | 4 +- runner | Bin 0 -> 31632 bytes runner.o | Bin 0 -> 4216 bytes test_comments.tok | 9 + test_generalTokenTest.tok | 61 ++ test_keywords.tok | 29 + test_operators.tok | 22 + test_otherpunc.tok | 7 + test_simpleIntTest.tok | 3 + test_simpleLiterals.tok | 62 ++ 14 files changed, 2720 insertions(+), 2 deletions(-) create mode 100644 flex.h create mode 100644 flex.o create mode 100644 lex.yy.c create mode 100755 runner create mode 100644 runner.o create mode 100644 test_comments.tok create mode 100644 test_generalTokenTest.tok create mode 100644 test_keywords.tok create mode 100644 test_operators.tok create mode 100644 test_otherpunc.tok create mode 100644 test_simpleIntTest.tok create mode 100644 test_simpleLiterals.tok diff --git a/Makefile b/Makefile index 1c78b93..81376c3 100644 --- a/Makefile +++ b/Makefile @@ -16,7 +16,10 @@ flex.o: lex.yy.c typedefs.h lex.yy.c: lexicalStructure.lex $(FLEX) -o lex.yy.c $(LEX) - + +debug: CFLAGS += -DDEBUG=1 +debug: clean runner + test: ./$(EXE) ./tests/test_comments.alpha ./$(EXE) ./tests/test_generalTokenTest.alpha diff --git a/flex.h b/flex.h new file mode 100644 index 0000000..c528013 --- /dev/null +++ b/flex.h @@ -0,0 +1,477 @@ +#ifndef yyHEADER_H +#define yyHEADER_H 1 +#define yyIN_HEADER 1 + +#line 6 "flex.h" + +#line 8 "flex.h" + +#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 + +/* 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 + +#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; + +#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; + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +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 ); + +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 * ); + +/* Begin user sect3 */ + +#define yywrap() (/*CONSTCOND*/1) +#define YY_SKIP_YYWRAP + +extern int yylineno; + +extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif +#define yytext_ptr yytext + +#ifdef YY_HEADER_EXPORT_START_CONDITIONS +#define INITIAL 0 + +#endif + +#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 + +/* 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 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 + +#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 + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* 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 */ + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +#undef YY_NEW_FILE +#undef YY_FLUSH_BUFFER +#undef yy_set_bol +#undef yy_new_buffer +#undef yy_set_interactive +#undef YY_DO_BEFORE_ACTION + +#ifdef YY_DECL_IS_OURS +#undef YY_DECL_IS_OURS +#undef YY_DECL +#endif + +#ifndef yy_create_buffer_ALREADY_DEFINED +#undef yy_create_buffer +#endif +#ifndef yy_delete_buffer_ALREADY_DEFINED +#undef yy_delete_buffer +#endif +#ifndef yy_scan_buffer_ALREADY_DEFINED +#undef yy_scan_buffer +#endif +#ifndef yy_scan_string_ALREADY_DEFINED +#undef yy_scan_string +#endif +#ifndef yy_scan_bytes_ALREADY_DEFINED +#undef yy_scan_bytes +#endif +#ifndef yy_init_buffer_ALREADY_DEFINED +#undef yy_init_buffer +#endif +#ifndef yy_flush_buffer_ALREADY_DEFINED +#undef yy_flush_buffer +#endif +#ifndef yy_load_buffer_state_ALREADY_DEFINED +#undef yy_load_buffer_state +#endif +#ifndef yy_switch_to_buffer_ALREADY_DEFINED +#undef yy_switch_to_buffer +#endif +#ifndef yypush_buffer_state_ALREADY_DEFINED +#undef yypush_buffer_state +#endif +#ifndef yypop_buffer_state_ALREADY_DEFINED +#undef yypop_buffer_state +#endif +#ifndef yyensure_buffer_stack_ALREADY_DEFINED +#undef yyensure_buffer_stack +#endif +#ifndef yylex_ALREADY_DEFINED +#undef yylex +#endif +#ifndef yyrestart_ALREADY_DEFINED +#undef yyrestart +#endif +#ifndef yylex_init_ALREADY_DEFINED +#undef yylex_init +#endif +#ifndef yylex_init_extra_ALREADY_DEFINED +#undef yylex_init_extra +#endif +#ifndef yylex_destroy_ALREADY_DEFINED +#undef yylex_destroy +#endif +#ifndef yyget_debug_ALREADY_DEFINED +#undef yyget_debug +#endif +#ifndef yyset_debug_ALREADY_DEFINED +#undef yyset_debug +#endif +#ifndef yyget_extra_ALREADY_DEFINED +#undef yyget_extra +#endif +#ifndef yyset_extra_ALREADY_DEFINED +#undef yyset_extra +#endif +#ifndef yyget_in_ALREADY_DEFINED +#undef yyget_in +#endif +#ifndef yyset_in_ALREADY_DEFINED +#undef yyset_in +#endif +#ifndef yyget_out_ALREADY_DEFINED +#undef yyget_out +#endif +#ifndef yyset_out_ALREADY_DEFINED +#undef yyset_out +#endif +#ifndef yyget_leng_ALREADY_DEFINED +#undef yyget_leng +#endif +#ifndef yyget_text_ALREADY_DEFINED +#undef yyget_text +#endif +#ifndef yyget_lineno_ALREADY_DEFINED +#undef yyget_lineno +#endif +#ifndef yyset_lineno_ALREADY_DEFINED +#undef yyset_lineno +#endif +#ifndef yyget_column_ALREADY_DEFINED +#undef yyget_column +#endif +#ifndef yyset_column_ALREADY_DEFINED +#undef yyset_column +#endif +#ifndef yywrap_ALREADY_DEFINED +#undef yywrap +#endif +#ifndef yyget_lval_ALREADY_DEFINED +#undef yyget_lval +#endif +#ifndef yyset_lval_ALREADY_DEFINED +#undef yyset_lval +#endif +#ifndef yyget_lloc_ALREADY_DEFINED +#undef yyget_lloc +#endif +#ifndef yyset_lloc_ALREADY_DEFINED +#undef yyset_lloc +#endif +#ifndef yyalloc_ALREADY_DEFINED +#undef yyalloc +#endif +#ifndef yyrealloc_ALREADY_DEFINED +#undef yyrealloc +#endif +#ifndef yyfree_ALREADY_DEFINED +#undef yyfree +#endif +#ifndef yytext_ALREADY_DEFINED +#undef yytext +#endif +#ifndef yyleng_ALREADY_DEFINED +#undef yyleng +#endif +#ifndef yyin_ALREADY_DEFINED +#undef yyin +#endif +#ifndef yyout_ALREADY_DEFINED +#undef yyout +#endif +#ifndef yy_flex_debug_ALREADY_DEFINED +#undef yy_flex_debug +#endif +#ifndef yylineno_ALREADY_DEFINED +#undef yylineno +#endif +#ifndef yytables_fload_ALREADY_DEFINED +#undef yytables_fload +#endif +#ifndef yytables_destroy_ALREADY_DEFINED +#undef yytables_destroy +#endif +#ifndef yyTABLES_NAME_ALREADY_DEFINED +#undef yyTABLES_NAME +#endif + +#line 76 "lexicalStructure.lex" + + +#line 476 "flex.h" +#undef yyIN_HEADER +#endif /* yyHEADER_H */ diff --git a/flex.o b/flex.o new file mode 100644 index 0000000000000000000000000000000000000000..c0c6827f98437382a2536fac1e48819a8616fb92 GIT binary patch literal 27880 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 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 42 +#define YY_END_OF_BUFFER 43 +/* 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[131] = + { 0, + 0, 0, 43, 41, 40, 24, 41, 20, 25, 41, + 41, 18, 16, 30, 17, 27, 19, 32, 29, 28, + 21, 22, 39, 39, 39, 39, 39, 39, 39, 39, + 39, 39, 39, 26, 0, 34, 0, 0, 0, 0, + 31, 32, 23, 39, 39, 39, 13, 39, 39, 39, + 39, 39, 6, 39, 39, 39, 39, 39, 39, 39, + 33, 0, 0, 39, 39, 39, 39, 39, 39, 39, + 39, 39, 39, 39, 39, 39, 39, 39, 39, 35, + 0, 39, 39, 39, 8, 39, 39, 39, 39, 38, + 39, 39, 39, 7, 36, 9, 39, 39, 39, 39, + + 39, 37, 39, 39, 39, 39, 39, 5, 39, 39, + 39, 39, 39, 39, 39, 39, 11, 3, 2, 39, + 39, 39, 1, 14, 15, 39, 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, 1, 4, 5, 1, 1, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 18, 19, 20, + 21, 22, 1, 1, 23, 24, 23, 23, 23, 23, + 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, + 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, + 1, 25, 1, 1, 23, 1, 26, 23, 27, 28, + + 29, 30, 31, 32, 33, 23, 23, 34, 23, 35, + 36, 37, 23, 38, 39, 40, 41, 42, 43, 44, + 45, 23, 1, 46, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 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[47] = + { 0, + 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, + 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, + 1, 1, 4, 4, 1, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 1 + } ; + +static const flex_int16_t yy_base[135] = + { 0, + 0, 0, 160, 161, 161, 161, 42, 161, 161, 134, + 147, 161, 161, 161, 135, 161, 161, 139, 134, 161, + 161, 161, 0, 118, 20, 121, 16, 23, 21, 111, + 122, 20, 118, 161, 48, 161, 49, 141, 47, 137, + 161, 130, 161, 0, 110, 117, 0, 118, 104, 102, + 107, 105, 0, 99, 104, 23, 108, 95, 98, 101, + 161, 122, 58, 98, 93, 92, 100, 99, 88, 99, + 96, 90, 94, 93, 80, 85, 90, 89, 83, 161, + 60, 87, 86, 88, 0, 75, 83, 71, 79, 0, + 83, 70, 69, 0, 0, 0, 77, 79, 65, 76, + + 67, 0, 63, 66, 53, 46, 51, 0, 50, 44, + 41, 54, 43, 40, 48, 47, 0, 0, 0, 46, + 40, 37, 0, 0, 0, 28, 0, 0, 0, 161, + 89, 93, 57, 97 + } ; + +static const flex_int16_t yy_def[135] = + { 0, + 130, 1, 130, 130, 130, 130, 131, 130, 130, 132, + 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, + 130, 130, 133, 133, 133, 133, 133, 133, 133, 133, + 133, 133, 133, 130, 131, 130, 130, 130, 130, 134, + 130, 130, 130, 133, 133, 133, 133, 133, 133, 133, + 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, + 130, 134, 134, 133, 133, 133, 133, 133, 133, 133, + 133, 133, 133, 133, 133, 133, 133, 133, 133, 130, + 134, 133, 133, 133, 133, 133, 133, 133, 133, 133, + 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, + + 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, + 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, + 133, 133, 133, 133, 133, 133, 133, 133, 133, 0, + 130, 130, 130, 130 + } ; + +static const flex_int16_t yy_nxt[208] = + { 0, + 4, 4, 5, 6, 7, 8, 9, 10, 11, 4, + 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 22, 4, 23, 24, 4, 25, 26, 23, 27, 28, + 23, 23, 29, 23, 30, 23, 23, 31, 23, 32, + 23, 23, 33, 23, 23, 34, 36, 46, 51, 49, + 53, 57, 36, 35, 38, 54, 73, 58, 47, 50, + 44, 74, 75, 52, 59, 129, 37, 80, 81, 130, + 81, 128, 37, 127, 126, 125, 124, 123, 122, 121, + 120, 38, 119, 35, 118, 117, 38, 116, 35, 35, + 35, 115, 35, 38, 114, 113, 38, 62, 62, 62, + + 62, 112, 111, 110, 109, 108, 107, 106, 105, 104, + 103, 102, 101, 100, 99, 98, 97, 96, 95, 94, + 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, + 83, 82, 63, 79, 78, 77, 76, 72, 71, 70, + 69, 68, 67, 66, 65, 64, 42, 63, 61, 60, + 56, 55, 48, 45, 43, 42, 41, 40, 39, 130, + 3, 130, 130, 130, 130, 130, 130, 130, 130, 130, + 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, + 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, + 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, + + 130, 130, 130, 130, 130, 130, 130 + } ; + +static const flex_int16_t yy_chk[208] = + { 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, 7, 25, 28, 27, + 29, 32, 35, 37, 39, 29, 56, 32, 25, 27, + 133, 56, 56, 28, 32, 126, 7, 63, 63, 81, + 81, 122, 35, 121, 120, 116, 115, 114, 113, 112, + 111, 39, 110, 37, 109, 107, 39, 106, 37, 131, + 131, 105, 131, 132, 104, 103, 132, 134, 134, 134, + + 134, 101, 100, 99, 98, 97, 93, 92, 91, 89, + 88, 87, 86, 84, 83, 82, 79, 78, 77, 76, + 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, + 65, 64, 62, 60, 59, 58, 57, 55, 54, 52, + 51, 50, 49, 48, 46, 45, 42, 40, 38, 33, + 31, 30, 26, 24, 19, 18, 15, 11, 10, 3, + 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, + 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, + 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, + 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, + + 130, 130, 130, 130, 130, 130, 130 + } ; + +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 544 "lex.yy.c" +#line 21 "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 548 "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 25 "lexicalStructure.lex" + + +#line 768 "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 >= 131 ) + 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] != 161 ); + +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 27 "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 28 "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 29 "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 30 "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 32 "lexicalStructure.lex" +{if(DEBUG) {printf( "WHILE: %s (%d)\n", yytext, WHILE);} else {return WHILE;}} + YY_BREAK +case 6: +YY_RULE_SETUP +#line 33 "lexicalStructure.lex" +{if(DEBUG) {printf( "IF: %s (%d)\n", yytext, IF);} else {return IF;}} + YY_BREAK +case 7: +YY_RULE_SETUP +#line 34 "lexicalStructure.lex" +{if(DEBUG) {printf( "THEN: %s (%d)\n", yytext, THEN);} else {return THEN;}} + YY_BREAK +case 8: +YY_RULE_SETUP +#line 35 "lexicalStructure.lex" +{if(DEBUG) {printf( "ELSE: %s (%d)\n", yytext, ELSE);} else {return ELSE;}} + YY_BREAK +case 9: +YY_RULE_SETUP +#line 36 "lexicalStructure.lex" +{if(DEBUG) {printf( "TYPE: %s (%d)\n", yytext, TYPE);} else {return TYPE;}} + YY_BREAK +case 10: +YY_RULE_SETUP +#line 37 "lexicalStructure.lex" +{if(DEBUG) {printf( "FUNCTION: %s (%d)\n", yytext, FUNCTION);} else {return FUNCTION;}} + YY_BREAK +case 11: +YY_RULE_SETUP +#line 38 "lexicalStructure.lex" +{if(DEBUG) {printf( "RETURN: %s (%d)\n", yytext, RETURN);} else {return RETURN;}} + YY_BREAK +case 12: +YY_RULE_SETUP +#line 39 "lexicalStructure.lex" +{if(DEBUG) {printf( "EXTERNAL: %s (%d)\n", yytext, EXTERNAL);} else {return EXTERNAL;}} + YY_BREAK +case 13: +YY_RULE_SETUP +#line 40 "lexicalStructure.lex" +{if(DEBUG) {printf( "AS: %s (%d)\n", yytext, AS);} else {return AS;}} + YY_BREAK +case 14: +YY_RULE_SETUP +#line 42 "lexicalStructure.lex" +{if(DEBUG) {printf( "RELEASE: %s (%d)\n", yytext, RELEASE);} else {return RELEASE;}} + YY_BREAK +case 15: +YY_RULE_SETUP +#line 43 "lexicalStructure.lex" +{if(DEBUG) {printf( "RESERVE: %s (%d)\n", yytext, RESERVE);} else {return RESERVE;}} + YY_BREAK +case 16: +YY_RULE_SETUP +#line 45 "lexicalStructure.lex" +{if(DEBUG) {printf( "ADD: %s (%d)\n", yytext, ADD);} else {return ADD;}} + YY_BREAK +case 17: +YY_RULE_SETUP +#line 46 "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 47 "lexicalStructure.lex" +{if(DEBUG) {printf( "MUL: %s (%d)\n", yytext, MUL);} else {return MUL;}} + YY_BREAK +case 19: +YY_RULE_SETUP +#line 48 "lexicalStructure.lex" +{if(DEBUG) {printf( "DIV: %s (%d)\n", yytext, DIV);} else {return DIV;}} + YY_BREAK +case 20: +YY_RULE_SETUP +#line 49 "lexicalStructure.lex" +{if(DEBUG) {printf( "REM: %s (%d)\n", yytext, REM);} else {return REM;}} + YY_BREAK +case 21: +YY_RULE_SETUP +#line 50 "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 51 "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 52 "lexicalStructure.lex" +{if(DEBUG) {printf( "ASSIGN: %s (%d)\n", yytext, ASSIGN);} else {return ASSIGN;}} + YY_BREAK +case 24: +YY_RULE_SETUP +#line 53 "lexicalStructure.lex" +{if(DEBUG) {printf( "NOT: %s (%d)\n", yytext, NOT);} else {return NOT;}} + YY_BREAK +case 25: +YY_RULE_SETUP +#line 54 "lexicalStructure.lex" +{if(DEBUG) {printf( "AND: %s (%d)\n", yytext, AND);} else {return AND;}} + YY_BREAK +case 26: +YY_RULE_SETUP +#line 55 "lexicalStructure.lex" +{if(DEBUG) {printf( "OR: %s (%d)\n", yytext, OR);} else {return OR;}} + YY_BREAK +case 27: +YY_RULE_SETUP +#line 56 "lexicalStructure.lex" +{if(DEBUG) {printf( "DOT: %s (%d)\n", yytext, DOT);} else {return DOT;}} + YY_BREAK +case 28: +YY_RULE_SETUP +#line 58 "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 59 "lexicalStructure.lex" +{if(DEBUG) {printf( "COLON: %s (%d)\n", yytext, COLON);} else {return COLON;}} + YY_BREAK +case 30: +YY_RULE_SETUP +#line 60 "lexicalStructure.lex" +{if(DEBUG) {printf( "COMMA: %s (%d)\n", yytext, COMMA);} else {return COMMA;}} + YY_BREAK +case 31: +YY_RULE_SETUP +#line 61 "lexicalStructure.lex" +{if(DEBUG) {printf( "ARROW: %s (%d)\n", yytext, ARROW);} else {return ARROW;}} + YY_BREAK +case 32: +YY_RULE_SETUP +#line 63 "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 64 "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 65 "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 66 "lexicalStructure.lex" +{if(DEBUG) {printf( "COMMENT: %s (%d)\n", yytext, COMMENT);} else {return COMMENT;}} + YY_BREAK +case 36: +YY_RULE_SETUP +#line 67 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_TRUE: %s (%d)\n", yytext, C_TRUE);} else {return C_TRUE;}} + YY_BREAK +case 37: +YY_RULE_SETUP +#line 68 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_FALSE: %s (%d)\n", yytext, C_FALSE);} else {return C_FALSE;}} + YY_BREAK +case 38: +YY_RULE_SETUP +#line 69 "lexicalStructure.lex" +{if(DEBUG) {printf( "C_NULL: %s (%d)\n", yytext, C_NULL);} else {return C_NULL;}} + YY_BREAK +case 39: +YY_RULE_SETUP +#line 71 "lexicalStructure.lex" +{if(DEBUG) {printf( "ID: %s (%d)\n", yytext, ID);} else {return ID;}} + YY_BREAK +case 40: +/* rule 40 can match eol */ +YY_RULE_SETUP +#line 73 "lexicalStructure.lex" +{line_number++; column_number = 1;} + YY_BREAK +case 41: +YY_RULE_SETUP +#line 74 "lexicalStructure.lex" +{column_number++;} + YY_BREAK +case 42: +YY_RULE_SETUP +#line 76 "lexicalStructure.lex" +ECHO; + YY_BREAK +#line 1037 "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 >= 131 ) + 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 >= 131 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 130); + + 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 76 "lexicalStructure.lex" + + diff --git a/lexicalStructure.lex b/lexicalStructure.lex index a79ebfd..86799c2 100644 --- a/lexicalStructure.lex +++ b/lexicalStructure.lex @@ -8,7 +8,9 @@ #include #include "typedefs.h" int line_number = 1, column_number = 1; - bool DEBUG = false; + #ifndef DEBUG + #define DEBUG 0 + #endif %} COM ([^*]|\*+[^)*])* diff --git a/runner b/runner new file mode 100755 index 0000000000000000000000000000000000000000..1af2d69cd79231bcee0f7ba1fc3fffd4f4a080ab GIT binary patch literal 31632 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 literal 0 HcmV?d00001 diff --git a/runner.o b/runner.o new file mode 100644 index 0000000000000000000000000000000000000000..00c2836f5eb4c7ad11fa80c9286bd62f68f1c66b GIT binary patch literal 4216 zcmbtWU1(fI6rN4mq}H@a>tAg}ZVS~Y%{6Ib(NgQyvgS(tqZlbzh@0KJ-EDX8E_d&> ziDlcu8uhXS1bt8t!6)%W3i?n*N>oTG6v=}vd8p7AA+>pk+K07O>iOo**^IY)@xeo8 zXXZQKIdkUBnYlTcdj8ptL_)A6#2&FcV^oM{&+<4ahe@$ktPy|oK6qo)3VyNbi-SS! zvK9Dq_1fixw~Kx|PY%;>hyR+@NX=RGnN?OpSi!jkmzjq3Q|pq zsc8kXk<}=ujd2=Z5BCA`8z1gPxhgHtCa%;{xP^|8gKYI7TWzRv3)h|wlT>eZ_`_D? zDKZm{HS$+(y5TQU#7oZwf9?&Itm((0p&XwndzbK5(0iAjxQADzMi87%Mu zL2AA+IuB&|7%9pgbwpP`4Q+{^x&qeO#{h8b0Yxg~4}-4HBoyxoQ-aiGs)G7LhxK82 za?7SospzsYb5`R8IH%J1k?q21SdCVIVs2WAxpTtw%139DE3oP2wQd#VzY;`StThAw zdLwncz7Tqswr%UKTUPqDl`79d6r4BG#X{C7I2GSBjupJTF|^Itvtyf4b`7WO7-qUy z$)}C9d)QblT#+s0a%?0rc{_7-tnB4&7j)%oEaV;&TeAlKc4Un$TdP}Eivik;2>l5$ zvTxrmqknYVcRb%18Zw8?!GR%PPKQox-);^LKcZkd03lXT>!XHh9eHt7P+`vi>!b#` zJM2W_%>yDa(U;iN)4l3Fy3e>mXpk=4hSb`=w>$Q&>FWGDK@_RmEww^y#>>#sZ)oWc zDg6j~)}MfNyuj58@f%)-+oZGYi-^6no}HG>Y8tJRyAL7k8M2nzdd-jA8)0`*L!P3t zkpS=?Rtb}PA*`QTJ3h+39lkRLM-JQZ_Y#hEIX;S z#^fZiiH7S#MwwEDAkUugM5bKyOU{_%m&R>Z6bp{c<6OlpI9`s3MSDWzGR1Ng&RsW? zcSR;$ES58vI+@BOMJ&Xy{0;9}7mfeI7m;MYhIeZ?&I5ugg?qsKBLGQ&qtqC80g|A8 z@1Vx`y8ubRhprhed+QT`B<$zWa4J4mJ-E0V?B}$?!M{_(XB7@U{^el)yu#W4HZ{MZ zdhqf6WB%_7Xa10y-%x#&zY-4s3HW+`?$>bS=Sh%A_+G$|o}Zl&KIeU}!ok<`uwUat z$N5ZaIM(HS7GwNWHNKwD;~EbCoS%0z9B&ij(;D8Z;qPlW-VNq|rs0V5AT`KW3dfr3 zs4@R*4PUR}=QTfi{1;>JpEW;tL)rhY8eiY<%^3bL4xEJRBp*)2ZiT~#URQ@ST)%e} z4cG78afPEpez*=l()joma{S+FxbFWa4aa|Y%)hST_i8wQXc52eXETBzffTVP5K{Wpz5VF^bd=iA9j4R;?i^MdXr=WPj-GR=cY@xisb)w z2AQLzkXv1nYT~H8u}+mAPsJu0A*aa}5)RIwct}n`NrJloTf9k-4Phr9q8@l;8SzCF zQ2glnICuDr(oZWuEw8M@SX&bsppM~FKYQre9^Y+UIDW?Pj>3MB0oC`bg}E+S&GB>p z3@Lcb9Q3b516Rr@_W_V5`!dxFFURev92qDeG=c+=b2pHlIAnk|M=`+op2 CgEuw+ literal 0 HcmV?d00001 diff --git a/test_comments.tok b/test_comments.tok new file mode 100644 index 0000000..2fb6907 --- /dev/null +++ b/test_comments.tok @@ -0,0 +1,9 @@ +1 1 700 "(* hello *)" +2 1 700 "(* hello *)" +3 1 700 "(* I'd think this is a legal "string" that contains several \n \t +escaped characters, isn't it? *)" +4 1 700 "(* \ *)" +5 1 700 "(* *)" +6 1 700 "(*{COMMENT}+ *)" +7 1 700 "(* * *)" +8 1 700 "(* (hello) *)" diff --git a/test_generalTokenTest.tok b/test_generalTokenTest.tok new file mode 100644 index 0000000..69b1571 --- /dev/null +++ b/test_generalTokenTest.tok @@ -0,0 +1,61 @@ +1 1 101 "This" +1 2 101 "is" +1 3 101 "a" +1 4 101 "test" +2 1 301 "9" +2 1 101 "combined" +2 2 301 "7" +2 2 101 "okens" +3 1 301 "12345" +4 1 301 "893247892" +5 1 101 "combined" +5 2 101 "DueToUnknownChar" +5 3 101 "_validtoken" +5 4 101 "__validtoken1" +5 5 101 "_valid_token2" +5 6 101 "validToken3_" +6 1 305 "true" +6 2 306 "false" +7 1 302 "null" +7 2 401 "while" +7 3 609 "!" +7 3 101 "wrong" +7 4 402 "if" +7 5 101 "when" +8 1 404 "else" +8 2 405 "type" +8 3 406 "function" +9 1 407 "return" +9 3 408 "external" +9 11 409 "as" +10 1 101 "string" +10 2 101 "_NOte_that_was_not_reserved" +11 7 508 ":" +11 7 507 ";" +11 7 509 "," +11 7 510 "->" +12 1 601 "+" +12 1 602 "-" +12 1 603 "*" +12 1 604 "/" +12 1 605 "%" +13 1 606 "<" +13 1 607 "=" +14 1 608 ":=" +15 2 101 "This" +15 3 101 "is" +15 4 101 "not" +15 5 101 "a" +15 6 101 "valid" +16 1 101 "String" +17 1 304 ""This is a valid String"" +18 1 609 "!" +18 1 611 "|" +19 1 612 "." +19 1 612 "." +20 1 700 "(* this is a comment *)" +21 2 603 "*" +21 2 101 "Not" +21 3 101 "a" +21 4 101 "comment" +22 3 610 "&" diff --git a/test_keywords.tok b/test_keywords.tok new file mode 100644 index 0000000..9e70321 --- /dev/null +++ b/test_keywords.tok @@ -0,0 +1,29 @@ +1 1 401 "while" +2 1 101 "While" +3 1 101 "whiLe" +4 1 402 "if" +5 1 101 "IF" +6 1 101 "If" +7 1 101 "iF" +8 1 403 "then" +9 1 101 "Then" +10 1 101 "theN" +11 1 404 "else" +12 1 101 "eLse" +13 1 101 "elSe" +14 1 101 "Else" +15 1 405 "type" +16 1 101 "Type" +17 1 101 "tyPe" +18 1 406 "function" +19 1 101 "Function" +20 1 101 "functioN" +21 1 407 "return" +22 1 101 "Return" +23 1 101 "returN" +24 1 408 "external" +25 1 101 "External" +26 1 101 "exteRnal" +27 1 409 "as" +28 1 101 "As" +29 1 101 "aS" diff --git a/test_operators.tok b/test_operators.tok new file mode 100644 index 0000000..9ca0302 --- /dev/null +++ b/test_operators.tok @@ -0,0 +1,22 @@ +1 1 601 "+" +2 1 602 "-" +3 1 603 "*" +4 1 604 "/" +6 1 605 "%" +7 1 606 "<" +9 1 607 "=" +10 1 608 ":=" +11 1 607 "=" +11 1 508 ":" +12 1 508 ":" +13 1 607 "=" +14 1 609 "!" +15 1 610 "&" +16 1 611 "|" +17 1 612 "." +18 1 101 "relEASE" +19 1 614 "release" +20 1 101 "RELEASE" +21 1 613 "reserve" +22 1 101 "RESERVE" +23 1 101 "reSERVe" diff --git a/test_otherpunc.tok b/test_otherpunc.tok new file mode 100644 index 0000000..005f61c --- /dev/null +++ b/test_otherpunc.tok @@ -0,0 +1,7 @@ +1 1 507 ";" +2 1 508 ":" +3 1 509 "," +4 1 510 "->" +5 1 510 "->" +6 1 602 "-" +6 1 510 "->" diff --git a/test_simpleIntTest.tok b/test_simpleIntTest.tok new file mode 100644 index 0000000..2bdbdd3 --- /dev/null +++ b/test_simpleIntTest.tok @@ -0,0 +1,3 @@ +1 1 301 "45" +2 1 301 "123" +3 1 301 "8392" diff --git a/test_simpleLiterals.tok b/test_simpleLiterals.tok new file mode 100644 index 0000000..51f07e1 --- /dev/null +++ b/test_simpleLiterals.tok @@ -0,0 +1,62 @@ +1 1 304 ""this is a string"" +1 2 301 "721398" +1 3 303 "'g'" +1 5 604 "/" +1 5 101 "n" +1 7 700 "(* should print 3 tokens before this *)" +4 1 301 "12893" +4 3 101 "this" +4 4 101 "is" +4 5 101 "not" +4 6 101 "a" +4 7 101 "string" +4 8 700 "(*one valid token before this*)" +5 1 700 "(* spacey comment here +over multiple lines +will it work? *)" +9 1 306 "false" +10 1 700 "(**)" +12 1 101 "nullfalse" +13 2 101 "nulltrue" +14 1 302 "null" +15 1 303 "'7'" +16 1 305 "true" +17 2 301 "189" +18 1 303 "'\t'" +19 1 303 "'"'" +20 1 303 "'/'" +21 1 303 "'\n'" +22 1 303 "'\''" +23 1 303 "'\t'" +25 1 303 "'n'" +27 2 101 "fdsf" +28 1 700 "(*/jnewjno2893u86^ Lots of random characters /n /t '") *)" +33 1 304 ""STRINGwithnotSPaces"" +34 1 303 "' '" +36 1 304 ""J"" +37 1 304 """" +38 1 304 "" "" +40 1 304 ""{SCHAR}"" +41 1 304 ""SCHAR"" +42 1 304 ""[SCHAR]"" +43 1 304 ""FINAL: I'd think this is a legal \"string\" that contains \n \t several escaped characters, isn't it?"" +44 2 101 "I" +44 3 101 "d" +44 4 101 "think" +44 5 101 "this" +44 6 101 "is" +44 7 101 "a" +44 8 101 "legal" +44 11 101 "string" +44 14 101 "that" +44 15 101 "contains" +44 16 101 "several" +44 19 101 "n" +44 21 101 "t" +44 22 101 "escaped" +44 23 101 "characters" +44 23 509 "," +44 24 101 "isn" +44 25 101 "t" +44 26 101 "it" +45 1 101 "nullLike"