From f64a4633f7da195a7ca139cf8e56e82be3859d5d Mon Sep 17 00:00:00 2001 From: Partho Bhattacharya Date: Thu, 13 Feb 2025 18:51:31 -0500 Subject: [PATCH] tweaked the lexer to always have DEBUG of 0 and updated .tok file logic in runner --- Makefile | 11 +- Makefile.save | 43 + flex.h | 477 +++++++++ flex.o | Bin 0 -> 34384 bytes lex.yy.c | 2041 +++++++++++++++++++++++++++++++++++++ lexicalStructure.lex | 4 +- runner | Bin 0 -> 31688 bytes runner.c | 31 +- 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 ++ 16 files changed, 2783 insertions(+), 17 deletions(-) create mode 100644 Makefile.save 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 ff000b2..1c78b93 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,7 @@ CC := gcc FLEX := flex LEX := lexicalStructure.lex -EXE := lexicalStructure +EXE := runner CFLAGS := -std=c99 -Wall CPPFLAGS := @@ -25,9 +25,16 @@ test: ./$(EXE) ./tests/test_otherpunc.alpha ./$(EXE) ./tests/test_simpleIntTest.alpha ./$(EXE) ./tests/test_simpleLiterals.alpha - + ./$(EXE) -tok ./tests/test_comments.alpha + ./$(EXE) -tok ./tests/test_generalTokenTest.alpha + ./$(EXE) -tok ./tests/test_keywords.alpha + ./$(EXE) -tok ./tests/test_operators.alpha + ./$(EXE) -tok ./tests/test_otherpunc.alpha + ./$(EXE) -tok ./tests/test_simpleIntTest.alpha + ./$(EXE) -tok ./tests/test_simpleLiterals.alpha clean: rm -f *.o rm -f lex.yy.c rm -f $(EXE) rm -f flex.h + rm -f *.tok diff --git a/Makefile.save b/Makefile.save new file mode 100644 index 0000000..668af54 --- /dev/null +++ b/Makefile.save @@ -0,0 +1,43 @@ +CC := gcc +FLEX := flex +LEX := lexicalStructure.lex +EXE := runner +CFLAGS := -std=c99 -Wall +CPPFLAGS := + +runner: flex.o runner.o + $(CC) -o runner runner.o flex.o + +debug: CFLAGS += -DDEBUG=true +debug: clean runner + +runner.o: runner.c runner.h flex.h + $(CC) $(CFLAGS) -o runner.o -c runner.c + +flex.o: lex.yy.c typedefs.h + $(CC) $(CFLAGS) -o flex.o -c lex.yy.c + +lex.yy.c: lexicalStructure.lex + $(FLEX) -o lex.yy.c $(LEX) + +test: + ./$(EXE) ./tests/test_comments.alpha + ./$(EXE) ./tests/test_generalTokenTest.alpha + ./$(EXE) ./tests/test_keywords.alpha + ./$(EXE) ./tests/test_operators.alpha + ./$(EXE) ./tests/test_otherpunc.alpha + ./$(EXE) ./tests/test_simpleIntTest.alpha + ./$(EXE) ./tests/test_simpleLiterals.alpha + ./$(EXE) -tok ./tests/test_comments.alpha + ./$(EXE) -tok ./tests/test_generalTokenTest.alpha + ./$(EXE) -tok ./tests/test_keywords.alpha + ./$(EXE) -tok ./tests/test_operators.alpha + ./$(EXE) -tok ./tests/test_otherpunc.alpha + ./$(EXE) -tok ./tests/test_simpleIntTest.alpha + ./$(EXE) -tok ./tests/test_simpleLiterals.alpha +clean: + rm -f *.o + rm -f lex.yy.c + rm -f $(EXE) + rm -f flex.h + rm -f *.tok diff --git a/flex.h b/flex.h new file mode 100644 index 0000000..c017827 --- /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 74 "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..f8acaf4d65edcb38fda1c8c1d0b8b8eb3e684a64 GIT binary patch literal 34384 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

ODBcCr)Uy++WxcC5XA! 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 literal 0 HcmV?d00001 diff --git a/lex.yy.c b/lex.yy.c new file mode 100644 index 0000000..69aedb9 --- /dev/null +++ b/lex.yy.c @@ -0,0 +1,2041 @@ +#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 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; + bool DEBUG = false; +#line 542 "lex.yy.c" +#line 19 "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 546 "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 23 "lexicalStructure.lex" + + +#line 766 "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 25 "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 26 "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 27 "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 28 "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 30 "lexicalStructure.lex" +{if(DEBUG) {printf( "WHILE: %s (%d)\n", yytext, WHILE);} else {return WHILE;}} + YY_BREAK +case 6: +YY_RULE_SETUP +#line 31 "lexicalStructure.lex" +{if(DEBUG) {printf( "IF: %s (%d)\n", yytext, IF);} else {return IF;}} + YY_BREAK +case 7: +YY_RULE_SETUP +#line 32 "lexicalStructure.lex" +{if(DEBUG) {printf( "THEN: %s (%d)\n", yytext, THEN);} else {return THEN;}} + YY_BREAK +case 8: +YY_RULE_SETUP +#line 33 "lexicalStructure.lex" +{if(DEBUG) {printf( "ELSE: %s (%d)\n", yytext, ELSE);} else {return ELSE;}} + YY_BREAK +case 9: +YY_RULE_SETUP +#line 34 "lexicalStructure.lex" +{if(DEBUG) {printf( "TYPE: %s (%d)\n", yytext, TYPE);} else {return TYPE;}} + YY_BREAK +case 10: +YY_RULE_SETUP +#line 35 "lexicalStructure.lex" +{if(DEBUG) {printf( "FUNCTION: %s (%d)\n", yytext, FUNCTION);} else {return FUNCTION;}} + YY_BREAK +case 11: +YY_RULE_SETUP +#line 36 "lexicalStructure.lex" +{if(DEBUG) {printf( "RETURN: %s (%d)\n", yytext, RETURN);} else {return RETURN;}} + YY_BREAK +case 12: +YY_RULE_SETUP +#line 37 "lexicalStructure.lex" +{if(DEBUG) {printf( "EXTERNAL: %s (%d)\n", yytext, EXTERNAL);} else {return EXTERNAL;}} + YY_BREAK +case 13: +YY_RULE_SETUP +#line 38 "lexicalStructure.lex" +{if(DEBUG) {printf( "AS: %s (%d)\n", yytext, AS);} else {return AS;}} + YY_BREAK +case 14: +YY_RULE_SETUP +#line 40 "lexicalStructure.lex" +{if(DEBUG) {printf( "RELEASE: %s (%d)\n", yytext, RELEASE);} else {return RELEASE;}} + YY_BREAK +case 15: +YY_RULE_SETUP +#line 41 "lexicalStructure.lex" +{if(DEBUG) {printf( "RESERVE: %s (%d)\n", yytext, RESERVE);} else {return RESERVE;}} + YY_BREAK +case 16: +YY_RULE_SETUP +#line 43 "lexicalStructure.lex" +{if(DEBUG) {printf( "ADD: %s (%d)\n", yytext, ADD);} else {return ADD;}} + YY_BREAK +case 17: +YY_RULE_SETUP +#line 44 "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 45 "lexicalStructure.lex" +{if(DEBUG) {printf( "MUL: %s (%d)\n", yytext, MUL);} else {return MUL;}} + YY_BREAK +case 19: +YY_RULE_SETUP +#line 46 "lexicalStructure.lex" +{if(DEBUG) {printf( "DIV: %s (%d)\n", yytext, DIV);} else {return DIV;}} + YY_BREAK +case 20: +YY_RULE_SETUP +#line 47 "lexicalStructure.lex" +{if(DEBUG) {printf( "REM: %s (%d)\n", yytext, REM);} else {return REM;}} + YY_BREAK +case 21: +YY_RULE_SETUP +#line 48 "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 49 "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 50 "lexicalStructure.lex" +{if(DEBUG) {printf( "ASSIGN: %s (%d)\n", yytext, ASSIGN);} else {return ASSIGN;}} + YY_BREAK +case 24: +YY_RULE_SETUP +#line 51 "lexicalStructure.lex" +{if(DEBUG) {printf( "NOT: %s (%d)\n", yytext, NOT);} else {return NOT;}} + YY_BREAK +case 25: +YY_RULE_SETUP +#line 52 "lexicalStructure.lex" +{if(DEBUG) {printf( "AND: %s (%d)\n", yytext, AND);} else {return AND;}} + YY_BREAK +case 26: +YY_RULE_SETUP +#line 53 "lexicalStructure.lex" +{if(DEBUG) {printf( "OR: %s (%d)\n", yytext, OR);} else {return OR;}} + YY_BREAK +case 27: +YY_RULE_SETUP +#line 54 "lexicalStructure.lex" +{if(DEBUG) {printf( "DOT: %s (%d)\n", yytext, DOT);} else {return DOT;}} + YY_BREAK +case 28: +YY_RULE_SETUP +#line 56 "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 57 "lexicalStructure.lex" +{if(DEBUG) {printf( "COLON: %s (%d)\n", yytext, COLON);} else {return COLON;}} + YY_BREAK +case 30: +YY_RULE_SETUP +#line 58 "lexicalStructure.lex" +{if(DEBUG) {printf( "COMMA: %s (%d)\n", yytext, COMMA);} else {return COMMA;}} + YY_BREAK +case 31: +YY_RULE_SETUP +#line 59 "lexicalStructure.lex" +{if(DEBUG) {printf( "ARROW: %s (%d)\n", yytext, ARROW);} else {return ARROW;}} + YY_BREAK +case 32: +YY_RULE_SETUP +#line 61 "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 62 "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 63 "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 64 "lexicalStructure.lex" +{if(DEBUG) {printf( "COMMENT: %s (%d)\n", yytext, COMMENT);} else {return COMMENT;}} + YY_BREAK +case 36: +YY_RULE_SETUP +#line 65 "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 66 "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 67 "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 69 "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 71 "lexicalStructure.lex" +{line_number++; column_number = 1;} + YY_BREAK +case 41: +YY_RULE_SETUP +#line 72 "lexicalStructure.lex" +{column_number++;} + YY_BREAK +case 42: +YY_RULE_SETUP +#line 74 "lexicalStructure.lex" +ECHO; + YY_BREAK +#line 1035 "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 74 "lexicalStructure.lex" + + diff --git a/lexicalStructure.lex b/lexicalStructure.lex index eed6e7d..a79ebfd 100644 --- a/lexicalStructure.lex +++ b/lexicalStructure.lex @@ -8,7 +8,7 @@ #include #include "typedefs.h" int line_number = 1, column_number = 1; - bool DEBUG = true; + bool DEBUG = false; %} COM ([^*]|\*+[^)*])* @@ -70,4 +70,4 @@ SCHAR \\n|\\t|\\\"|[^\"\n\\] \n {line_number++; column_number = 1;} . {column_number++;} -%% \ No newline at end of file +%% diff --git a/runner b/runner new file mode 100755 index 0000000000000000000000000000000000000000..620f79ca8f59f14b034d2ad92795a58beb68cd82 GIT binary patch literal 31688 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 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"