/******************************************************************** This file is part of the abs 0.908 distribution. abs is a spreadsheet with graphical user interface. Copyright (C) 1998-2001 André Bertin (Andre.Bertin@ping.be) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version if in the same spirit as version 2. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Concact: abs@pi.be http://home.pi.be/bertin/abs.shtml *********************************************************************/ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 5 #include #ifdef c_plusplus #ifndef __cplusplus #define __cplusplus #endif #endif #ifdef __cplusplus #include #include #define YY_USE_PROTOS #define YY_USE_CONST #else #if __STDC__ #define YY_USE_PROTOS #define YY_USE_CONST #endif #endif #ifdef __TURBOC__ #pragma warn -rch #pragma warn -use #include #include #define YY_USE_CONST #define YY_USE_PROTOS #endif #ifdef YY_USE_CONST #define yyconst const #else #define yyconst #endif #ifdef YY_USE_PROTOS #define YY_PROTO(proto) proto #else #define YY_PROTO(proto) () #endif #define YY_NULL 0 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) #define BEGIN yy_start = 1 + 2 * #define YY_START ((yy_start - 1) / 2) #define YYSTATE YY_START #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) #define YY_NEW_FILE yyrestart( yyin ) #define YY_END_OF_BUFFER_CHAR 0 #define YY_BUF_SIZE 16384 typedef struct yy_buffer_state *YY_BUFFER_STATE; 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 yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ *yy_cp = yy_hold_char; \ YY_RESTORE_YY_MORE_OFFSET \ yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) #define unput(c) yyunput( c, yytext_ptr ) typedef unsigned int yy_size_t; struct yy_buffer_state { FILE *yy_input_file; char *yy_ch_buf; char *yy_buf_pos; yy_size_t yy_buf_size; int yy_n_chars; int yy_is_our_buffer; int yy_is_interactive; int yy_at_bol; int yy_fill_buffer; int yy_buffer_status; #define YY_BUFFER_NEW 0 #define YY_BUFFER_NORMAL 1 #define YY_BUFFER_EOF_PENDING 2 }; static YY_BUFFER_STATE yy_current_buffer = 0; #define YY_CURRENT_BUFFER yy_current_buffer static char yy_hold_char; static int yy_n_chars; int yyleng; static char *yy_c_buf_p = (char *) 0; static int yy_init = 1; static int yy_start = 0; static int yy_did_buffer_switch_on_eof; void yyrestart YY_PROTO ((FILE * input_file)); void yy_switch_to_buffer YY_PROTO ((YY_BUFFER_STATE new_buffer)); void yy_load_buffer_state YY_PROTO ((void)); YY_BUFFER_STATE yy_create_buffer YY_PROTO ((FILE * file, int size)); void yy_delete_buffer YY_PROTO ((YY_BUFFER_STATE b)); void yy_init_buffer YY_PROTO ((YY_BUFFER_STATE b, FILE * file)); void yy_flush_buffer YY_PROTO ((YY_BUFFER_STATE b)); #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) YY_BUFFER_STATE yy_scan_buffer YY_PROTO ((char *base, yy_size_t size)); YY_BUFFER_STATE yy_scan_string YY_PROTO ((yyconst char *yy_str)); YY_BUFFER_STATE yy_scan_bytes YY_PROTO ((yyconst char *bytes, int len)); static void *yy_flex_alloc YY_PROTO ((yy_size_t)); static void *yy_flex_realloc YY_PROTO ((void *, yy_size_t)); static void yy_flex_free YY_PROTO ((void *)); #define yy_new_buffer yy_create_buffer #define yy_set_interactive(is_interactive) \ { \ if ( ! yy_current_buffer ) \ yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ yy_current_buffer->yy_is_interactive = is_interactive; \ } #define yy_set_bol(at_bol) \ { \ if ( ! yy_current_buffer ) \ yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ yy_current_buffer->yy_at_bol = at_bol; \ } #define YY_AT_BOL() (yy_current_buffer->yy_at_bol) typedef unsigned char YY_CHAR; FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; typedef int yy_state_type; extern char *yytext; #define yytext_ptr yytext static yy_state_type yy_get_previous_state YY_PROTO ((void)); static yy_state_type yy_try_NUL_trans YY_PROTO ((yy_state_type current_state)); static int yy_get_next_buffer YY_PROTO ((void)); static void yy_fatal_error YY_PROTO ((yyconst char msg[])); #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 110 #define YY_END_OF_BUFFER 111 static yyconst short int yy_accept[338] = {0, 0, 0, 111, 107, 106, 104, 105, 88, 107, 62, 96, 87, 107, 82, 83, 93, 92, 78, 91, 86, 94, 68, 68, 79, 75, 97, 80, 99, 103, 84, 95, 85, 101, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 76, 102, 77, 90, 0, 74, 0, 62, 0, 70, 0, 0, 63, 72, 73, 66, 0, 68, 68, 0, 68, 98, 89, 81, 100, 62, 62, 3, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 17, 62, 62, 62, 62, 62, 62, 62, 26, 27, 62, 62, 62, 62, 62, 35, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 44, 62, 62, 62, 62, 62, 62, 0, 63, 0, 72, 72, 0, 73, 66, 66, 0, 71, 68, 69, 64, 1, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 16, 62, 62, 62, 60, 62, 62, 24, 62, 62, 62, 62, 62, 40, 62, 62, 62, 62, 62, 62, 62, 62, 62, 47, 62, 59, 62, 62, 62, 58, 42, 62, 62, 62, 62, 62, 62, 62, 108, 0, 72, 0, 72, 0, 73, 66, 67, 71, 64, 64, 62, 62, 62, 62, 62, 9, 62, 61, 11, 62, 62, 62, 15, 62, 21, 22, 62, 23, 62, 62, 62, 30, 31, 41, 62, 33, 62, 62, 62, 62, 62, 62, 62, 62, 62, 50, 62, 43, 62, 62, 54, 62, 55, 62, 0, 72, 64, 65, 62, 62, 62, 62, 8, 10, 12, 13, 62, 62, 62, 62, 28, 62, 62, 62, 62, 37, 62, 62, 62, 62, 62, 62, 62, 52, 62, 56, 57, 2, 62, 6, 62, 62, 18, 62, 62, 62, 32, 34, 36, 62, 39, 45, 46, 48, 49, 51, 62, 62, 7, 62, 62, 62, 29, 38, 53, 62, 14, 62, 62, 25, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 19, 62, 62, 20, 62, 4, 5, 0 }; static yyconst int yy_ec[256] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 5, 6, 1, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 22, 23, 24, 25, 26, 1, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 42, 48, 49, 50, 51, 52, 53, 54, 55, 42, 27, 28, 29, 30, 31, 1, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 42, 48, 49, 50, 51, 52, 53, 54, 55, 42, 56, 57, 58, 59, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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 yyconst int yy_meta[60] = {0, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 1, 1, 1, 1 }; static yyconst short int yy_base[344] = {0, 0, 0, 420, 421, 421, 421, 421, 421, 54, 0, 421, 421, 51, 421, 421, 421, 421, 421, 421, 43, 421, 47, 52, 421, 421, 49, 395, 394, 421, 421, 421, 421, 421, 31, 45, 43, 64, 70, 19, 47, 371, 370, 379, 60, 58, 382, 78, 73, 368, 380, 87, 421, 421, 421, 421, 71, 421, 408, 0, 110, 421, 407, 111, 0, 111, 113, 117, 126, 358, 365, 139, 144, 421, 421, 421, 421, 372, 359, 0, 367, 359, 357, 100, 134, 356, 356, 352, 349, 354, 346, 362, 346, 359, 356, 352, 343, 345, 0, 94, 120, 354, 334, 346, 119, 0, 336, 345, 351, 338, 135, 337, 347, 150, 347, 346, 342, 0, 327, 328, 330, 334, 323, 332, 160, 0, 180, 421, 170, 188, 421, 320, 327, 172, 190, 421, 421, 100, 0, 333, 328, 335, 323, 329, 328, 331, 319, 325, 311, 310, 310, 321, 0, 323, 316, 318, 322, 0, 302, 0, 317, 299, 313, 310, 300, 0, 296, 309, 299, 303, 295, 160, 298, 305, 303, 0, 300, 0, 287, 289, 295, 0, 0, 289, 293, 292, 296, 287, 290, 278, 183, 195, 197, 204, 421, 202, 206, 421, 421, 421, 276, 283, 280, 279, 275, 286, 284, 0, 277, 0, 0, 283, 268, 281, 0, 273, 0, 0, 269, 0, 264, 263, 274, 0, 0, 0, 277, 0, 264, 258, 258, 275, 266, 259, 270, 260, 262, 0, 256, 0, 257, 267, 0, 262, 0, 261, 208, 210, 421, 421, 261, 264, 239, 261, 0, 0, 0, 0, 247, 255, 253, 249, 0, 252, 237, 241, 235, 0, 234, 249, 238, 231, 244, 245, 240, 0, 232, 0, 0, 0, 230, 0, 230, 240, 0, 242, 226, 223, 0, 0, 0, 234, 0, 0, 0, 0, 0, 0, 219, 215, 0, 196, 194, 205, 0, 0, 0, 217, 0, 201, 200, 0, 195, 197, 209, 197, 196, 197, 186, 188, 200, 183, 176, 159, 150, 141, 145, 128, 124, 130, 0, 79, 81, 0, 65, 0, 0, 421, 253, 256, 260, 263, 265, 65 }; static yyconst short int yy_def[344] = {0, 337, 1, 337, 337, 337, 337, 337, 337, 338, 339, 337, 337, 340, 337, 337, 337, 337, 337, 337, 341, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 337, 337, 337, 337, 338, 337, 338, 339, 340, 337, 340, 340, 342, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 340, 342, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 343, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 340, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 337, 337, 337, 337, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 339, 0, 337, 337, 337, 337, 337, 337 }; static yyconst short int yy_nxt[481] = {0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 10, 34, 35, 36, 37, 38, 39, 10, 10, 40, 10, 10, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 10, 10, 52, 53, 54, 55, 57, 61, 65, 65, 66, 96, 67, 67, 137, 66, 97, 72, 72, 73, 74, 84, 77, 57, 78, 62, 79, 80, 58, 68, 98, 81, 85, 63, 68, 86, 69, 82, 99, 103, 87, 69, 88, 336, 70, 58, 83, 71, 91, 70, 89, 115, 107, 104, 105, 108, 90, 106, 116, 92, 110, 93, 94, 335, 111, 117, 61, 61, 334, 120, 95, 112, 121, 122, 113, 114, 65, 65, 128, 128, 66, 123, 67, 67, 62, 62, 133, 161, 133, 200, 162, 134, 134, 126, 143, 129, 144, 201, 145, 68, 127, 168, 130, 124, 137, 137, 131, 66, 333, 72, 72, 163, 164, 332, 132, 169, 61, 137, 137, 137, 137, 137, 137, 146, 174, 331, 68, 330, 178, 147, 329, 175, 179, 69, 62, 128, 128, 134, 134, 61, 191, 70, 191, 190, 180, 192, 192, 328, 195, 327, 195, 230, 193, 196, 196, 134, 134, 62, 231, 194, 192, 192, 192, 192, 246, 326, 246, 196, 196, 247, 247, 196, 196, 247, 247, 247, 247, 309, 315, 199, 325, 324, 323, 322, 310, 316, 127, 321, 320, 319, 318, 317, 314, 313, 312, 130, 311, 308, 307, 194, 56, 56, 56, 56, 59, 59, 59, 60, 60, 60, 60, 64, 64, 125, 125, 306, 305, 304, 303, 302, 301, 300, 299, 298, 297, 296, 295, 294, 293, 292, 291, 290, 289, 288, 287, 286, 285, 284, 283, 282, 281, 280, 279, 278, 277, 276, 275, 274, 273, 272, 271, 270, 269, 268, 267, 266, 265, 264, 263, 262, 261, 260, 259, 258, 257, 256, 255, 254, 253, 252, 251, 250, 249, 248, 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 235, 234, 233, 232, 229, 228, 227, 226, 225, 224, 223, 222, 221, 220, 219, 218, 217, 216, 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, 198, 197, 189, 188, 187, 186, 185, 184, 183, 182, 181, 177, 176, 173, 172, 171, 170, 167, 166, 165, 160, 159, 158, 157, 156, 155, 154, 153, 152, 151, 150, 149, 148, 142, 141, 140, 139, 138, 136, 135, 337, 337, 119, 118, 109, 102, 101, 100, 76, 75, 337, 3, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337 }; static yyconst short int yy_chk[481] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 13, 20, 20, 22, 39, 22, 22, 343, 23, 39, 23, 23, 26, 26, 36, 34, 56, 34, 13, 34, 35, 9, 22, 40, 35, 36, 13, 23, 36, 22, 35, 40, 44, 36, 23, 37, 334, 22, 56, 35, 22, 38, 23, 37, 48, 45, 44, 44, 45, 37, 44, 48, 38, 47, 38, 38, 332, 47, 48, 60, 63, 331, 51, 38, 47, 51, 51, 47, 47, 65, 65, 66, 66, 67, 51, 67, 67, 60, 63, 68, 99, 68, 137, 99, 68, 68, 65, 83, 66, 83, 137, 83, 67, 65, 104, 66, 63, 71, 71, 67, 72, 329, 72, 72, 100, 100, 328, 67, 104, 124, 71, 71, 71, 71, 71, 71, 84, 110, 327, 72, 326, 113, 84, 325, 110, 113, 72, 124, 128, 128, 133, 133, 190, 126, 72, 126, 124, 113, 126, 126, 324, 129, 323, 129, 171, 128, 129, 129, 134, 134, 190, 171, 128, 191, 191, 192, 192, 193, 322, 193, 195, 195, 193, 193, 196, 196, 246, 246, 247, 247, 302, 312, 134, 321, 320, 319, 318, 302, 312, 192, 317, 316, 315, 314, 313, 310, 309, 307, 196, 303, 301, 299, 247, 338, 338, 338, 338, 339, 339, 339, 340, 340, 340, 340, 341, 341, 342, 342, 298, 291, 287, 286, 285, 283, 282, 280, 276, 274, 273, 272, 271, 270, 269, 268, 266, 265, 264, 263, 261, 260, 259, 258, 253, 252, 251, 250, 245, 243, 241, 240, 238, 236, 235, 234, 233, 232, 231, 230, 229, 228, 226, 222, 221, 220, 218, 215, 213, 212, 211, 208, 206, 205, 204, 203, 202, 201, 200, 189, 188, 187, 186, 185, 184, 183, 180, 179, 178, 176, 174, 173, 172, 170, 169, 168, 167, 166, 164, 163, 162, 161, 160, 158, 156, 155, 154, 153, 151, 150, 149, 148, 147, 146, 145, 144, 143, 142, 141, 140, 139, 132, 131, 123, 122, 121, 120, 119, 118, 116, 115, 114, 112, 111, 109, 108, 107, 106, 103, 102, 101, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 82, 81, 80, 78, 77, 70, 69, 62, 58, 50, 49, 46, 43, 42, 41, 28, 27, 3, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337 }; static yy_state_type yy_last_accepting_state; static char *yy_last_accepting_cpos; #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 "parser.l" #define INITIAL 0 #line 12 "parser.l" #include #include "y.tab.h" #include "parser_ext.h" #include "gram_ext.h" extern int yyerror (char *s); #ifdef MYLEXDEBUG #define LEXRETURN(x) printf("Lex: %d (%s)\n", (x), yytext); return (x) #else #define LEXRETURN(x) return(x) #endif static int eqisboolean = 0; int seteqboolean () { eqisboolean = 1; return 0; } int unseteqboolean () { eqisboolean = 0; return 0; } extern int yylval; #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus extern "C" int yywrap YY_PROTO ((void)); #else extern int yywrap YY_PROTO ((void)); #endif #endif #ifndef YY_NO_UNPUT static void yyunput YY_PROTO ((int c, char *buf_ptr)); #endif #ifndef yytext_ptr static void yy_flex_strncpy YY_PROTO ((char *, yyconst char *, int)); #endif #ifdef YY_NEED_STRLEN static int yy_flex_strlen YY_PROTO ((yyconst char *)); #endif #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput YY_PROTO ((void)); #else static int input YY_PROTO ((void)); #endif #endif #if YY_STACK_USED static int yy_start_stack_ptr = 0; static int yy_start_stack_depth = 0; static int *yy_start_stack = 0; #ifndef YY_NO_PUSH_STATE static void yy_push_state YY_PROTO ((int new_state)); #endif #ifndef YY_NO_POP_STATE static void yy_pop_state YY_PROTO ((void)); #endif #ifndef YY_NO_TOP_STATE static int yy_top_state YY_PROTO ((void)); #endif #else #define YY_NO_PUSH_STATE 1 #define YY_NO_POP_STATE 1 #define YY_NO_TOP_STATE 1 #endif #ifdef YY_MALLOC_DECL YY_MALLOC_DECL #else #if __STDC__ #ifndef __cplusplus #include #endif #else #endif #endif #ifndef YY_READ_BUF_SIZE #define YY_READ_BUF_SIZE 8192 #endif #ifndef ECHO #define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) #endif #ifndef YY_INPUT #define YY_INPUT(buf,result,max_size) \ if ( yy_current_buffer->yy_is_interactive ) \ { \ int c = '*', 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 if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ && ferror( yyin ) ) \ YY_FATAL_ERROR( "input in flex scanner failed" ); #endif #ifndef yyterminate #define yyterminate() return YY_NULL #endif #ifndef YY_START_STACK_INCR #define YY_START_STACK_INCR 25 #endif #ifndef YY_FATAL_ERROR #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) #endif #ifndef YY_DECL #define YY_DECL int yylex YY_PROTO(( void )) #endif #ifndef YY_USER_ACTION #define YY_USER_ACTION #endif #ifndef YY_BREAK #define YY_BREAK break; #endif #define YY_RULE_SETUP \ YY_USER_ACTION YY_DECL { register yy_state_type yy_current_state; register char *yy_cp = NULL, *yy_bp = NULL; register int yy_act; #line 33 "parser.l" if (yy_init) { yy_init = 0; #ifdef YY_USER_INIT YY_USER_INIT; #endif if (!yy_start) yy_start = 1; if (!yyin) yyin = stdin; if (!yyout) yyout = stdout; if (!yy_current_buffer) yy_current_buffer = yy_create_buffer (yyin, YY_BUF_SIZE); yy_load_buffer_state (); } while (1) { yy_cp = yy_c_buf_p; *yy_cp = yy_hold_char; yy_bp = yy_cp; yy_current_state = yy_start; yy_match: do { register 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 >= 338) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++yy_cp; } while (yy_base[yy_current_state] != 421); yy_find_action: yy_act = yy_accept[yy_current_state]; if (yy_act == 0) { 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: switch (yy_act) { case 0: *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 34 "parser.l" { LEXRETURN (AND); } YY_BREAK case 2: YY_RULE_SETUP #line 35 "parser.l" { LEXRETURN (APPEND); } YY_BREAK case 3: YY_RULE_SETUP #line 36 "parser.l" { LEXRETURN (AS); } YY_BREAK case 4: YY_RULE_SETUP #line 37 "parser.l" { LEXRETURN (BEGIN_OF_MODULE); } YY_BREAK case 5: YY_RULE_SETUP #line 38 "parser.l" { LEXRETURN (BEGIN_OF_FORMULA); } YY_BREAK case 6: YY_RULE_SETUP #line 39 "parser.l" { LEXRETURN (BINARY); } YY_BREAK case 7: YY_RULE_SETUP #line 40 "parser.l" { LEXRETURN (BOOLEAN); } YY_BREAK case 8: YY_RULE_SETUP #line 41 "parser.l" { LEXRETURN (BYREF); } YY_BREAK case 9: YY_RULE_SETUP #line 42 "parser.l" { LEXRETURN (BYTE); } YY_BREAK case 10: YY_RULE_SETUP #line 43 "parser.l" { LEXRETURN (BYVAL); } YY_BREAK case 11: YY_RULE_SETUP #line 44 "parser.l" { LEXRETURN (CASE); } YY_BREAK case 12: YY_RULE_SETUP #line 45 "parser.l" { LEXRETURN (CLOSE); } YY_BREAK case 13: YY_RULE_SETUP #line 46 "parser.l" { LEXRETURN (CONST); } YY_BREAK case 14: YY_RULE_SETUP #line 47 "parser.l" { LEXRETURN (CURRENCY); } YY_BREAK case 15: YY_RULE_SETUP #line 48 "parser.l" { LEXRETURN (DATE); } YY_BREAK case 16: YY_RULE_SETUP #line 49 "parser.l" { LEXRETURN (DIM); } YY_BREAK case 17: YY_RULE_SETUP #line 50 "parser.l" { LEXRETURN (DO); } YY_BREAK case 18: YY_RULE_SETUP #line 51 "parser.l" { LEXRETURN (DOUBLE); } YY_BREAK case 19: YY_RULE_SETUP #line 52 "parser.l" { LEXRETURN (END_OF_MODULE); } YY_BREAK case 20: YY_RULE_SETUP #line 53 "parser.l" { LEXRETURN (END_OF_FORMULA); } YY_BREAK case 21: YY_RULE_SETUP #line 54 "parser.l" { LEXRETURN (EACH); } YY_BREAK case 22: YY_RULE_SETUP #line 55 "parser.l" { LEXRETURN (ELSE); } YY_BREAK case 23: YY_RULE_SETUP #line 56 "parser.l" { LEXRETURN (EXIT); } YY_BREAK case 24: YY_RULE_SETUP #line 57 "parser.l" { LEXRETURN (FOR); } YY_BREAK case 25: YY_RULE_SETUP #line 58 "parser.l" { LEXRETURN (FUNCTION); } YY_BREAK case 26: YY_RULE_SETUP #line 59 "parser.l" { eqisboolean = 1; LEXRETURN (IF); } YY_BREAK case 27: YY_RULE_SETUP #line 60 "parser.l" { LEXRETURN (IN); } YY_BREAK case 28: YY_RULE_SETUP #line 61 "parser.l" { LEXRETURN (INPUT); } YY_BREAK case 29: YY_RULE_SETUP #line 62 "parser.l" { LEXRETURN (INTEGER); } YY_BREAK case 30: YY_RULE_SETUP #line 63 "parser.l" { LEXRETURN (LONG); } YY_BREAK case 31: YY_RULE_SETUP #line 64 "parser.l" { LEXRETURN (LOOP); } YY_BREAK case 32: YY_RULE_SETUP #line 65 "parser.l" { LEXRETURN (OBJECT); } YY_BREAK case 33: YY_RULE_SETUP #line 66 "parser.l" { LEXRETURN (OPEN); } YY_BREAK case 34: YY_RULE_SETUP #line 67 "parser.l" { LEXRETURN (OPTION); } YY_BREAK case 35: YY_RULE_SETUP #line 68 "parser.l" { LEXRETURN (OR); } YY_BREAK case 36: YY_RULE_SETUP #line 69 "parser.l" { LEXRETURN (OUTPUT); } YY_BREAK case 37: YY_RULE_SETUP #line 70 "parser.l" { LEXRETURN (PRINT); } YY_BREAK case 38: YY_RULE_SETUP #line 71 "parser.l" { LEXRETURN (PRIVATE); } YY_BREAK case 39: YY_RULE_SETUP #line 72 "parser.l" { LEXRETURN (PUBLIC); } YY_BREAK case 40: YY_RULE_SETUP #line 73 "parser.l" { LEXRETURN (MOD); } YY_BREAK case 41: YY_RULE_SETUP #line 74 "parser.l" { LEXRETURN (NEXT); } YY_BREAK case 42: YY_RULE_SETUP #line 75 "parser.l" { LEXRETURN (TAB); } YY_BREAK case 43: YY_RULE_SETUP #line 76 "parser.l" { eqisboolean = 0; LEXRETURN (THEN); } YY_BREAK case 44: YY_RULE_SETUP #line 77 "parser.l" { LEXRETURN (TO); } YY_BREAK case 45: YY_RULE_SETUP #line 78 "parser.l" { LEXRETURN (RANDOM); } YY_BREAK case 46: YY_RULE_SETUP #line 79 "parser.l" { LEXRETURN (SELECT); } YY_BREAK case 47: YY_RULE_SETUP #line 80 "parser.l" { LEXRETURN (SET); } YY_BREAK case 48: YY_RULE_SETUP #line 81 "parser.l" { LEXRETURN (SINGLE); } YY_BREAK case 49: YY_RULE_SETUP #line 82 "parser.l" { LEXRETURN (STATIC); } YY_BREAK case 50: YY_RULE_SETUP #line 83 "parser.l" { LEXRETURN (STEP); } YY_BREAK case 51: YY_RULE_SETUP #line 84 "parser.l" { LEXRETURN (STRING); } YY_BREAK case 52: YY_RULE_SETUP #line 85 "parser.l" { eqisboolean = 1; LEXRETURN (UNTIL); } YY_BREAK case 53: YY_RULE_SETUP #line 86 "parser.l" { LEXRETURN (VARIANT); } YY_BREAK case 54: YY_RULE_SETUP #line 87 "parser.l" { LEXRETURN (WEND); } YY_BREAK case 55: YY_RULE_SETUP #line 88 "parser.l" { LEXRETURN (WITH); } YY_BREAK case 56: YY_RULE_SETUP #line 89 "parser.l" { eqisboolean = 1; LEXRETURN (WHILE); } YY_BREAK case 57: YY_RULE_SETUP #line 90 "parser.l" { LEXRETURN (WRITE); } YY_BREAK case 58: YY_RULE_SETUP #line 91 "parser.l" { LEXRETURN (SUB); } YY_BREAK case 59: YY_RULE_SETUP #line 92 "parser.l" { LEXRETURN (SPC); } YY_BREAK case 60: YY_RULE_SETUP #line 93 "parser.l" { LEXRETURN (END); } YY_BREAK case 61: YY_RULE_SETUP #line 94 "parser.l" { LEXRETURN (CALL); } YY_BREAK case 62: YY_RULE_SETUP #line 96 "parser.l" { int t; FillTokenBuf (yytext); t = check_type (); LEXRETURN (t); } YY_BREAK case 63: YY_RULE_SETUP #line 97 "parser.l" { int t; FillTokenBuf (yytext); t = check_member (); LEXRETURN (t); } YY_BREAK case 64: YY_RULE_SETUP #line 99 "parser.l" { FillTokenBuf (yytext); LEXRETURN (INTEGER_CONSTANT); } YY_BREAK case 65: YY_RULE_SETUP #line 100 "parser.l" { FillTokenBuf (yytext); LEXRETURN (INTEGER_CONSTANT); } YY_BREAK case 66: YY_RULE_SETUP #line 101 "parser.l" { FillTokenBuf (yytext); LEXRETURN (INTEGER_CONSTANT); } YY_BREAK case 67: YY_RULE_SETUP #line 102 "parser.l" { FillTokenBuf (yytext); LEXRETURN (INTEGER_CONSTANT); } YY_BREAK case 68: YY_RULE_SETUP #line 103 "parser.l" { FillTokenBuf (yytext); LEXRETURN (INTEGER_CONSTANT); } YY_BREAK case 69: YY_RULE_SETUP #line 104 "parser.l" { FillTokenBuf (yytext); LEXRETURN (INTEGER_CONSTANT); } YY_BREAK case 70: YY_RULE_SETUP #line 106 "parser.l" { int t; FillTokenBuf (yytext); t = check_type (); LEXRETURN (t); } YY_BREAK case 71: YY_RULE_SETUP #line 108 "parser.l" { FillTokenBuf (yytext); LEXRETURN (FLOATING_CONSTANT); } YY_BREAK case 72: YY_RULE_SETUP #line 109 "parser.l" { FillTokenBuf (yytext); LEXRETURN (FLOATING_CONSTANT); } YY_BREAK case 73: YY_RULE_SETUP #line 110 "parser.l" { FillTokenBuf (yytext); LEXRETURN (FLOATING_CONSTANT); } YY_BREAK case 74: YY_RULE_SETUP #line 112 "parser.l" { FillTokenBuf (yytext); LEXRETURN (STRING_CONSTANT); } YY_BREAK case 75: YY_RULE_SETUP #line 115 "parser.l" { LEXRETURN (';'); } YY_BREAK case 76: YY_RULE_SETUP #line 116 "parser.l" { LEXRETURN ('{'); } YY_BREAK case 77: YY_RULE_SETUP #line 117 "parser.l" { LEXRETURN ('}'); } YY_BREAK case 78: YY_RULE_SETUP #line 118 "parser.l" { LEXRETURN (','); } YY_BREAK case 79: YY_RULE_SETUP #line 119 "parser.l" { LEXRETURN (':'); } YY_BREAK case 80: YY_RULE_SETUP #line 120 "parser.l" { if (eqisboolean) LEXRETURN (EQ); LEXRETURN ('='); } YY_BREAK case 81: YY_RULE_SETUP #line 122 "parser.l" { LEXRETURN (EQ); } YY_BREAK case 82: YY_RULE_SETUP #line 123 "parser.l" { LEXRETURN ('('); } YY_BREAK case 83: YY_RULE_SETUP #line 124 "parser.l" { LEXRETURN (')'); } YY_BREAK case 84: YY_RULE_SETUP #line 125 "parser.l" { LEXRETURN ('['); } YY_BREAK case 85: YY_RULE_SETUP #line 126 "parser.l" { LEXRETURN (']'); } YY_BREAK case 86: YY_RULE_SETUP #line 127 "parser.l" { LEXRETURN ('.'); } YY_BREAK case 87: YY_RULE_SETUP #line 128 "parser.l" { LEXRETURN ('&'); } YY_BREAK case 88: YY_RULE_SETUP #line 129 "parser.l" { LEXRETURN ('!'); } YY_BREAK case 89: YY_RULE_SETUP #line 130 "parser.l" { LEXRETURN (NE); } YY_BREAK case 90: YY_RULE_SETUP #line 131 "parser.l" { LEXRETURN ('~'); } YY_BREAK case 91: YY_RULE_SETUP #line 132 "parser.l" { LEXRETURN ('-'); } YY_BREAK case 92: YY_RULE_SETUP #line 133 "parser.l" { LEXRETURN ('+'); } YY_BREAK case 93: YY_RULE_SETUP #line 134 "parser.l" { LEXRETURN ('*'); } YY_BREAK case 94: YY_RULE_SETUP #line 135 "parser.l" { LEXRETURN ('/'); } YY_BREAK case 95: YY_RULE_SETUP #line 136 "parser.l" { LEXRETURN ('\\'); } YY_BREAK case 96: YY_RULE_SETUP #line 137 "parser.l" { LEXRETURN ('%'); } YY_BREAK case 97: YY_RULE_SETUP #line 138 "parser.l" { LEXRETURN (LT); } YY_BREAK case 98: YY_RULE_SETUP #line 139 "parser.l" { LEXRETURN (LE); } YY_BREAK case 99: YY_RULE_SETUP #line 140 "parser.l" { LEXRETURN (GT); } YY_BREAK case 100: YY_RULE_SETUP #line 141 "parser.l" { LEXRETURN (GE); } YY_BREAK case 101: YY_RULE_SETUP #line 142 "parser.l" { LEXRETURN ('^'); } YY_BREAK case 102: YY_RULE_SETUP #line 143 "parser.l" { LEXRETURN ('|'); } YY_BREAK case 103: YY_RULE_SETUP #line 144 "parser.l" { LEXRETURN ('?'); } YY_BREAK case 104: YY_RULE_SETUP #line 146 "parser.l" { eqisboolean = 0; LEXRETURN (NEWLINE); } YY_BREAK case 105: YY_RULE_SETUP #line 147 "parser.l" { } YY_BREAK case 106: YY_RULE_SETUP #line 149 "parser.l" { } YY_BREAK case 107: YY_RULE_SETUP #line 151 "parser.l" { } YY_BREAK case 108: YY_RULE_SETUP #line 153 "parser.l" { yyerror ("unterminated quote"); } YY_BREAK case 109: YY_RULE_SETUP #line 157 "parser.l" { yyerror ("end of file"); } YY_BREAK case 110: YY_RULE_SETUP #line 161 "parser.l" ECHO; YY_BREAK case YY_STATE_EOF (INITIAL): yyterminate (); case YY_END_OF_BUFFER: { int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; *yy_cp = yy_hold_char; YY_RESTORE_YY_MORE_OFFSET if (yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW) { yy_n_chars = yy_current_buffer->yy_n_chars; yy_current_buffer->yy_input_file = yyin; yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; } if (yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars]) { yy_state_type yy_next_state; yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; yy_current_state = yy_get_previous_state (); yy_next_state = yy_try_NUL_trans (yy_current_state); yy_bp = yytext_ptr + YY_MORE_ADJ; if (yy_next_state) { 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 ()) { 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->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"); } } } static int yy_get_next_buffer () { register char *dest = yy_current_buffer->yy_ch_buf; register char *source = yytext_ptr; register int number_to_move, i; int ret_val; if (yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1]) YY_FATAL_ERROR ( "fatal flex scanner internal error--end of buffer missed"); if (yy_current_buffer->yy_fill_buffer == 0) { if (yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1) { return EOB_ACT_END_OF_FILE; } else { return EOB_ACT_LAST_MATCH; } } 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->yy_buffer_status == YY_BUFFER_EOF_PENDING) yy_current_buffer->yy_n_chars = yy_n_chars = 0; else { int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1; while (num_to_read <= 0) { #ifdef YY_USES_REJECT YY_FATAL_ERROR ( "input buffer overflow, can't enlarge buffer because scanner uses REJECT"); #else YY_BUFFER_STATE b = yy_current_buffer; 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 *) yy_flex_realloc ((void *) b->yy_ch_buf, b->yy_buf_size + 2); } else b->yy_ch_buf = 0; 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->yy_buf_size - number_to_move - 1; #endif } if (num_to_read > YY_READ_BUF_SIZE) num_to_read = YY_READ_BUF_SIZE; YY_INPUT ((&yy_current_buffer->yy_ch_buf[number_to_move]), yy_n_chars, num_to_read); yy_current_buffer->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->yy_buffer_status = YY_BUFFER_EOF_PENDING; } } else ret_val = EOB_ACT_CONTINUE_SCAN; yy_n_chars += number_to_move; yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; return ret_val; } static yy_state_type yy_get_previous_state () { register yy_state_type yy_current_state; register char *yy_cp; yy_current_state = yy_start; for (yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp) { register 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 >= 338) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; } return yy_current_state; } #ifdef YY_USE_PROTOS static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state) #else static yy_state_type yy_try_NUL_trans (yy_current_state) yy_state_type yy_current_state; #endif { register int yy_is_jam; register char *yy_cp = yy_c_buf_p; register 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 >= 338) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; yy_is_jam = (yy_current_state == 337); return yy_is_jam ? 0 : yy_current_state; } #ifndef YY_NO_UNPUT #ifdef YY_USE_PROTOS static void yyunput (int c, register char *yy_bp) #else static void yyunput (c, yy_bp) int c; register char *yy_bp; #endif { register char *yy_cp = yy_c_buf_p; *yy_cp = yy_hold_char; if (yy_cp < yy_current_buffer->yy_ch_buf + 2) { register int number_to_move = yy_n_chars + 2; register char *dest = &yy_current_buffer->yy_ch_buf[ yy_current_buffer->yy_buf_size + 2]; register char *source = &yy_current_buffer->yy_ch_buf[number_to_move]; while (source > yy_current_buffer->yy_ch_buf) *--dest = *--source; yy_cp += (int) (dest - source); yy_bp += (int) (dest - source); yy_current_buffer->yy_n_chars = yy_n_chars = yy_current_buffer->yy_buf_size; if (yy_cp < yy_current_buffer->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 #ifdef __cplusplus static int yyinput () #else static int input () #endif { int c; *yy_c_buf_p = yy_hold_char; if (*yy_c_buf_p == YY_END_OF_BUFFER_CHAR) { if (yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars]) *yy_c_buf_p = '\0'; else { int offset = yy_c_buf_p - yytext_ptr; ++yy_c_buf_p; switch (yy_get_next_buffer ()) { case EOB_ACT_LAST_MATCH: yyrestart (yyin); case EOB_ACT_END_OF_FILE: { if (yywrap ()) return EOF; 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; *yy_c_buf_p = '\0'; yy_hold_char = *++yy_c_buf_p; return c; } #ifdef YY_USE_PROTOS void yyrestart (FILE * input_file) #else void yyrestart (input_file) FILE *input_file; #endif { if (!yy_current_buffer) yy_current_buffer = yy_create_buffer (yyin, YY_BUF_SIZE); yy_init_buffer (yy_current_buffer, input_file); yy_load_buffer_state (); } #ifdef YY_USE_PROTOS void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer) #else void yy_switch_to_buffer (new_buffer) YY_BUFFER_STATE new_buffer; #endif { if (yy_current_buffer == new_buffer) return; if (yy_current_buffer) { *yy_c_buf_p = yy_hold_char; yy_current_buffer->yy_buf_pos = yy_c_buf_p; yy_current_buffer->yy_n_chars = yy_n_chars; } yy_current_buffer = new_buffer; yy_load_buffer_state (); yy_did_buffer_switch_on_eof = 1; } #ifdef YY_USE_PROTOS void yy_load_buffer_state (void) #else void yy_load_buffer_state () #endif { yy_n_chars = yy_current_buffer->yy_n_chars; yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; yyin = yy_current_buffer->yy_input_file; yy_hold_char = *yy_c_buf_p; } #ifdef YY_USE_PROTOS YY_BUFFER_STATE yy_create_buffer (FILE * file, int size) #else YY_BUFFER_STATE yy_create_buffer (file, size) FILE *file; int size; #endif { YY_BUFFER_STATE b; b = (YY_BUFFER_STATE) yy_flex_alloc (sizeof (struct yy_buffer_state)); if (!b) YY_FATAL_ERROR ("out of dynamic memory in yy_create_buffer()"); b->yy_buf_size = size; b->yy_ch_buf = (char *) yy_flex_alloc (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; } #ifdef YY_USE_PROTOS void yy_delete_buffer (YY_BUFFER_STATE b) #else void yy_delete_buffer (b) YY_BUFFER_STATE b; #endif { if (!b) return; if (b == yy_current_buffer) yy_current_buffer = (YY_BUFFER_STATE) 0; if (b->yy_is_our_buffer) yy_flex_free ((void *) b->yy_ch_buf); yy_flex_free ((void *) b); } #ifndef YY_ALWAYS_INTERACTIVE #ifndef YY_NEVER_INTERACTIVE extern int isatty YY_PROTO ((int)); #endif #endif #ifdef YY_USE_PROTOS void yy_init_buffer (YY_BUFFER_STATE b, FILE * file) #else void yy_init_buffer (b, file) YY_BUFFER_STATE b; FILE *file; #endif { yy_flush_buffer (b); b->yy_input_file = file; b->yy_fill_buffer = 1; #if YY_ALWAYS_INTERACTIVE b->yy_is_interactive = 1; #else #if YY_NEVER_INTERACTIVE b->yy_is_interactive = 0; #else b->yy_is_interactive = file ? (isatty (fileno (file)) > 0) : 0; #endif #endif } #ifdef YY_USE_PROTOS void yy_flush_buffer (YY_BUFFER_STATE b) #else void yy_flush_buffer (b) YY_BUFFER_STATE b; #endif { if (!b) return; b->yy_n_chars = 0; 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 (); } #ifndef YY_NO_SCAN_BUFFER #ifdef YY_USE_PROTOS YY_BUFFER_STATE yy_scan_buffer (char *base, yy_size_t size) #else YY_BUFFER_STATE yy_scan_buffer (base, size) char *base; yy_size_t size; #endif { YY_BUFFER_STATE b; if (size < 2 || base[size - 2] != YY_END_OF_BUFFER_CHAR || base[size - 1] != YY_END_OF_BUFFER_CHAR) return 0; b = (YY_BUFFER_STATE) yy_flex_alloc (sizeof (struct yy_buffer_state)); if (!b) YY_FATAL_ERROR ("out of dynamic memory in yy_scan_buffer()"); b->yy_buf_size = size - 2; b->yy_buf_pos = b->yy_ch_buf = base; b->yy_is_our_buffer = 0; b->yy_input_file = 0; 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; } #endif #ifndef YY_NO_SCAN_STRING #ifdef YY_USE_PROTOS YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str) #else YY_BUFFER_STATE yy_scan_string (yy_str) yyconst char *yy_str; #endif { int len; for (len = 0; yy_str[len]; ++len) ; return yy_scan_bytes (yy_str, len); } #endif #ifndef YY_NO_SCAN_BYTES #ifdef YY_USE_PROTOS YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes, int len) #else YY_BUFFER_STATE yy_scan_bytes (bytes, len) yyconst char *bytes; int len; #endif { YY_BUFFER_STATE b; char *buf; yy_size_t n; int i; n = len + 2; buf = (char *) yy_flex_alloc (n); if (!buf) YY_FATAL_ERROR ("out of dynamic memory in yy_scan_bytes()"); for (i = 0; i < len; ++i) buf[i] = bytes[i]; buf[len] = buf[len + 1] = YY_END_OF_BUFFER_CHAR; b = yy_scan_buffer (buf, n); if (!b) YY_FATAL_ERROR ("bad buffer in yy_scan_bytes()"); b->yy_is_our_buffer = 1; return b; } #endif #ifndef YY_NO_PUSH_STATE #ifdef YY_USE_PROTOS static void yy_push_state (int new_state) #else static void yy_push_state (new_state) int new_state; #endif { if (yy_start_stack_ptr >= yy_start_stack_depth) { yy_size_t new_size; yy_start_stack_depth += YY_START_STACK_INCR; new_size = yy_start_stack_depth * sizeof (int); if (!yy_start_stack) yy_start_stack = (int *) yy_flex_alloc (new_size); else yy_start_stack = (int *) yy_flex_realloc ( (void *) yy_start_stack, new_size); if (!yy_start_stack) YY_FATAL_ERROR ( "out of memory expanding start-condition stack"); } yy_start_stack[yy_start_stack_ptr++] = YY_START; BEGIN (new_state); } #endif #ifndef YY_NO_POP_STATE static void yy_pop_state () { if (--yy_start_stack_ptr < 0) YY_FATAL_ERROR ("start-condition stack underflow"); BEGIN (yy_start_stack[yy_start_stack_ptr]); } #endif #ifndef YY_NO_TOP_STATE static int yy_top_state () { return yy_start_stack[yy_start_stack_ptr - 1]; } #endif #ifndef YY_EXIT_FAILURE #define YY_EXIT_FAILURE 2 #endif #ifdef YY_USE_PROTOS static void yy_fatal_error (yyconst char msg[]) #else static void yy_fatal_error (msg) char msg[]; #endif { (void) fprintf (stderr, "%s\n", msg); exit (YY_EXIT_FAILURE); } #undef yyless #define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ yytext[yyleng] = yy_hold_char; \ yy_c_buf_p = yytext + n; \ yy_hold_char = *yy_c_buf_p; \ *yy_c_buf_p = '\0'; \ yyleng = n; \ } \ while ( 0 ) #ifndef yytext_ptr #ifdef YY_USE_PROTOS static void yy_flex_strncpy (char *s1, yyconst char *s2, int n) #else static void yy_flex_strncpy (s1, s2, n) char *s1; yyconst char *s2; int n; #endif { register int i; for (i = 0; i < n; ++i) s1[i] = s2[i]; } #endif #ifdef YY_NEED_STRLEN #ifdef YY_USE_PROTOS static int yy_flex_strlen (yyconst char *s) #else static int yy_flex_strlen (s) yyconst char *s; #endif { register int n; for (n = 0; s[n]; ++n) ; return n; } #endif #ifdef YY_USE_PROTOS static void * yy_flex_alloc (yy_size_t size) #else static void * yy_flex_alloc (size) yy_size_t size; #endif { return (void *) malloc (size); } #ifdef YY_USE_PROTOS static void * yy_flex_realloc (void *ptr, yy_size_t size) #else static void * yy_flex_realloc (ptr, size) void *ptr; yy_size_t size; #endif { return (void *) realloc ((char *) ptr, size); } #ifdef YY_USE_PROTOS static void yy_flex_free (void *ptr) #else static void yy_flex_free (ptr) void *ptr; #endif { free (ptr); } #if YY_MAIN int main () { yylex (); return 0; } #endif #line 161 "parser.l"