Skip to content

P
Postgres FD Implementation
Commit 672bc164 authored by Marc G. Fournier's avatar Marc G. Fournier
Browse files
Options

parent e70798db
Show whitespace changes
Inline Side-by-side
Showing with 1033 additions and 1186 deletions
README-1ST deleted 100644 → 0
View file @ e70798db
Operating Systems Known to Run PostgreSQL (at some point)
---------------------------------------------------------
The following list is a list of those operating systems upon which
PostgreSQL is known to work, including the date that it was last
tested:
| Operating System | Tested by | Date Tested |
+----------------------------+-----------------+----------------------+
| FreeBSD 3.0-CURRENT (aout) | scrappy@hub.org | September 14th, 1998 |
+----------------------------+-----------------+----------------------+
src/backend/parser/gram.c
View file @ 672bc164
......@@ -230,7 +230,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/parser/Attic/gram.c,v 2.35 1998/09/13 04:20:16 thomas Exp $
* $Header: /cvsroot/pgsql/src/backend/parser/Attic/gram.c,v 2.36 1998/09/15 02:25:05 scrappy Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
......@@ -4284,7 +4284,7 @@ static const short yycheck[] = { 3,
-1, -1, -1, -1, -1, -1, 205
};
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
#line 3 "/usr/lib/bison.simple"
#line 3 "/usr/share/misc/bison.simple"
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
......@@ -4477,7 +4477,7 @@ __yy_memcpy (char *to, char *from, int count)
#endif
#endif
#line 196 "/usr/lib/bison.simple"
#line 196 "/usr/share/misc/bison.simple"
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.
......@@ -10041,7 +10041,7 @@ case 886:
break;}
}
/* the action file gets copied in in place of this dollarsign */
#line 498 "/usr/lib/bison.simple"
#line 498 "/usr/share/misc/bison.simple"
yyvsp -= yylen;
yyssp -= yylen;
......
src/backend/parser/scan.c
View file @ 672bc164
/* A lexical scanner generated by flex */
/* Scanner skeleton version:
* $Header: /cvsroot/pgsql/src/backend/parser/Attic/scan.c,v 1.27 1998/09/01 04:30:41 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/parser/Attic/scan.c,v 1.28 1998/09/15 02:25:09 scrappy Exp $
*/
#define FLEX_SCANNER
......@@ -41,8 +41,8 @@
#endif /* ! __cplusplus */
#ifdef __TURBOC__
#pragma warn -rch
#pragma warn -use
#pragma warn -rch
#pragma warn -use
#include <io.h>
#include <stdlib.h>
#define YY_USE_CONST
......@@ -99,8 +99,7 @@
typedef struct yy_buffer_state *YY_BUFFER_STATE;
extern int yyleng;
extern FILE *yyin,
*yyout;
extern FILE *yyin, *yyout;
#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
......@@ -143,65 +142,61 @@ typedef unsigned int yy_size_t;
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
/* Size of input buffer in bytes, not including room for EOB
* characters.
*/
yy_size_t yy_buf_size;
/*
* Number of characters read into yy_ch_buf, not including EOB
/* 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.
/* 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.
/* 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.
/* 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;
/*
* Whether to try to fill the input buffer when we reach the end of
* it.
/* 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 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.
* 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
};
};
static YY_BUFFER_STATE yy_current_buffer = 0;
......@@ -215,8 +210,7 @@ static YY_BUFFER_STATE yy_current_buffer = 0;
/* 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 */
static int yy_n_chars; /* number of characters read into yy_ch_buf */
int yyleng;
......@@ -231,24 +225,23 @@ static int yy_start = 0; /* start state number */
*/
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));
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));
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 *));
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
......@@ -274,13 +267,12 @@ 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[]));
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[] ));
/* Done after the current pattern has been matched and before the
* corresponding action - sets up yytext.
......@@ -292,52 +284,53 @@ static void yy_fatal_error YY_PROTO((yyconst char msg[]));
*yy_cp = '\0'; \
yy_c_buf_p = yy_cp;
#define YY_NUM_RULES 41
#define YY_END_OF_BUFFER 42
static yyconst short int yy_acclist[177] =
{0,
#define YY_NUM_RULES 42
#define YY_END_OF_BUFFER 43
static yyconst short int yy_acclist[184] =
{ 0,
10, 10, 6, 6, 24, 24, 9, 9, 25, 25,
18, 18, 42, 40, 41, 39, 40, 41, 39, 41,
31, 40, 41, 22, 40, 41, 29, 31, 40, 41,
15, 40, 41, 29, 40, 41, 29, 31, 40, 41,
29, 31, 40, 41, 29, 40, 41, 29, 31, 40,
41, 36, 40, 41, 16418, 29, 31, 40, 41, 38,
40, 41, 16417, 38, 40, 41, 16417, 38, 40, 41,
16417, 10, 41, 8, 41, 3, 6, 41, 3, 6,
41, 3, 41, 6, 41, 24, 41, 23, 41, 9,
41, 14, 41, 41, 25, 41, 26, 41, 18, 41,
16, 41, 41, 31, 31, 31, 32, 31, 31, 36,
16418, 37, 16419, 4, 31, 31, 37, 16419, 27, 31,
38, 16417, 7, 13, 10, 6, 6, 5, 24, 9,
25, 18, 17, 20, 19, 20, 30, 28, 30, 28,
30, 32, 28, 1, 31, 31, 28, 30, 4, 31,
4, 31, 4, 31, 8226, 37, 16419, 37, 16419, 8225,
12, 5, 11, 21, 30, 8227, 37, 16419, 2, 4,
31, 30, 2, 2, 2, 2
};
18, 18, 43, 41, 42, 40, 41, 42, 40, 42,
32, 41, 42, 22, 41, 42, 29, 30, 32, 41,
42, 15, 41, 42, 29, 30, 41, 42, 29, 30,
32, 41, 42, 29, 30, 32, 41, 42, 29, 30,
41, 42, 29, 30, 32, 41, 42, 37, 41, 42,
16419, 29, 30, 32, 41, 42, 39, 41, 42,16418,
39, 41, 42,16418, 39, 41, 42,16418, 10, 42,
8, 42, 3, 6, 42, 3, 6, 42, 3, 42,
6, 42, 24, 42, 23, 42, 9, 42, 14, 42,
42, 25, 42, 26, 42, 18, 42, 16, 42, 42,
32, 32, 32, 33, 32, 32, 37,16419, 38,16420,
4, 32, 32, 38,16420, 27, 32, 39,16418, 7,
13, 10, 6, 6, 5, 24, 9, 25, 18, 17,
20, 19, 20, 31, 28, 31, 28, 31, 33, 28,
1, 32, 32, 28, 31, 4, 32, 4, 32, 4,
32, 8227, 38,16420, 38,16420, 8226, 12, 5, 11,
21, 31, 8228, 38,16420, 2, 4, 32, 31, 2,
2, 2, 2
} ;
static yyconst short int yy_accept[135] =
{0,
{ 0,
1, 1, 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 16, 19, 21, 24,
27, 31, 34, 37, 41, 45, 48, 52, 56, 60,
64, 68, 72, 74, 76, 79, 82, 84, 86, 88,
90, 92, 94, 95, 97, 99, 101, 103, 104, 105,
106, 106, 107, 108, 108, 109, 110, 110, 112, 114,
116, 117, 117, 117, 119, 119, 121, 121, 121, 123,
124, 125, 126, 126, 126, 127, 128, 128, 128, 129,
130, 131, 131, 131, 132, 133, 133, 133, 134, 135,
137, 138, 140, 143, 144, 144, 145, 146, 147, 149,
149, 149, 149, 149, 151, 153, 155, 156, 158, 158,
160, 161, 161, 161, 162, 163, 163, 163, 164, 164,
164, 165, 166, 167, 167, 169, 169, 172, 173, 174,
175, 176, 177, 177
};
27, 32, 35, 39, 44, 49, 53, 58, 62, 67,
71, 75, 79, 81, 83, 86, 89, 91, 93, 95,
97, 99, 101, 102, 104, 106, 108, 110, 111, 112,
113, 113, 114, 115, 115, 116, 117, 117, 119, 121,
123, 124, 124, 124, 126, 126, 128, 128, 128, 130,
131, 132, 133, 133, 133, 134, 135, 135, 135, 136,
137, 138, 138, 138, 139, 140, 140, 140, 141, 142,
144, 145, 147, 150, 151, 151, 152, 153, 154, 156,
156, 156, 156, 156, 158, 160, 162, 163, 165, 165,
167, 168, 168, 168, 169, 170, 170, 170, 171, 171,
171, 172, 173, 174, 174, 176, 176, 179, 180, 181,
182, 183, 184, 184
} ;
static yyconst int yy_ec[256] =
{0,
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
......@@ -366,17 +359,17 @@ static yyconst int yy_ec[256] =
17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
17, 17, 17, 17, 17
};
} ;
static yyconst int yy_meta[22] =
{0,
{ 0,
1, 2, 3, 4, 5, 4, 6, 1, 7, 8,
9, 10, 4, 11, 4, 4, 2, 2, 11, 2,
12
};
} ;
static yyconst short int yy_base[153] =
{0,
{ 0,
0, 0, 368, 361, 18, 31, 350, 343, 339, 338,
46, 48, 18, 31, 344, 451, 451, 451, 332, 451,
58, 451, 51, 12, 44, 71, 23, 84, 327, 64,
......@@ -394,10 +387,10 @@ static yyconst short int yy_base[153] =
252, 258, 451, 261, 273, 285, 297, 309, 321, 330,
338, 349, 361, 370, 379, 391, 403, 414, 426, 431,
435, 439
};
} ;
static yyconst short int yy_def[153] =
{0,
{ 0,
133, 1, 134, 134, 135, 135, 136, 136, 137, 137,
138, 138, 139, 139, 133, 133, 133, 133, 140, 133,
140, 133, 133, 21, 21, 133, 24, 133, 24, 141,
......@@ -415,10 +408,10 @@ static yyconst short int yy_def[153] =
133, 133, 0, 133, 133, 133, 133, 133, 133, 133,
133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
133, 133
};
} ;
static yyconst short int yy_nxt[473] =
{0,
{ 0,
16, 17, 18, 19, 20, 21, 22, 23, 24, 24,
25, 26, 27, 28, 29, 24, 30, 31, 30, 32,
16, 36, 55, 36, 47, 133, 37, 36, 36, 126,
......@@ -471,10 +464,10 @@ static yyconst short int yy_nxt[473] =
15, 133, 133, 133, 133, 133, 133, 133, 133, 133,
133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
133, 133
};
} ;
static yyconst short int yy_chk[473] =
{0,
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 5, 24, 5, 13, 24, 5, 5, 5, 128,
......@@ -527,16 +520,14 @@ static yyconst short int yy_chk[473] =
133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
133, 133
};
} ;
static yy_state_type yy_state_buf[YY_BUF_SIZE + 2],
*yy_state_ptr;
static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
static char *yy_full_match;
static int yy_lp;
static int yy_looking_for_trail_begin = 0;
static int yy_full_lp;
static int *yy_full_state;
#define YY_TRAILING_MASK 0x2000
#define YY_TRAILING_HEAD_MASK 0x4000
#define REJECT \
......@@ -553,7 +544,6 @@ goto find_rule; \
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
char *yytext;
#line 1 "scan.l"
#define INITIAL 0
#line 2 "scan.l"
......@@ -566,7 +556,7 @@ char *yytext;
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/parser/Attic/scan.c,v 1.27 1998/09/01 04:30:41 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/parser/Attic/scan.c,v 1.28 1998/09/15 02:25:09 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
......@@ -602,17 +592,14 @@ static char *parseCh;
/* MAX_PARSE_BUFFER is defined in miscadmin.h */
#define YYLMAX MAX_PARSE_BUFFER
#define YY_NO_UNPUT
extern int myinput(char *buf, int max);
extern int myinput(char* buf, int max);
#undef YY_INPUT
#define YY_INPUT(buf,result,max) {result = myinput(buf,max);}
#else
#undef input
int input();
#undef unput
void unput(char);
#endif /* FLEX_SCANNER */
extern YYSTYPE yylval;
......@@ -684,7 +671,7 @@ real [\-]?{digit}+\.{digit}+([Ee][-+]?{digit}+)?
* Other embedded escaped characters are matched explicitly and the leading
* backslash is dropped from the string. - thomas 1997-09-24
*/
#line 674 "lex.yy.c"
#line 675 "lex.yy.c"
/* Macros after this point can all be overridden by user definitions in
* section 1.
......@@ -692,36 +679,29 @@ real [\-]?{digit}+\.{digit}+([Ee][-+]?{digit}+)?
#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap YY_PROTO((void));
extern "C" int yywrap YY_PROTO(( void ));
#else
extern int yywrap YY_PROTO((void));
extern int yywrap YY_PROTO(( void ));
#endif
#endif
#ifndef YY_NO_UNPUT
static void yyunput YY_PROTO((int c, char *buf_ptr));
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));
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 *));
static int yy_flex_strlen YY_PROTO(( yyconst char * ));
#endif
#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int yyinput YY_PROTO((void));
static int yyinput YY_PROTO(( void ));
#else
static int input YY_PROTO((void));
static int input YY_PROTO(( void ));
#endif
#endif
......@@ -729,18 +709,14 @@ static int input YY_PROTO((void));
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));
static void yy_push_state YY_PROTO(( int new_state ));
#endif
#ifndef YY_NO_POP_STATE
static void yy_pop_state YY_PROTO((void));
static void yy_pop_state YY_PROTO(( void ));
#endif
#ifndef YY_NO_TOP_STATE
static int yy_top_state YY_PROTO((void));
static int yy_top_state YY_PROTO(( void ));
#endif
#else
......@@ -841,17 +817,16 @@ YY_MALLOC_DECL
YY_USER_ACTION
YY_DECL
{
{
register yy_state_type yy_current_state;
register char *yy_cp,
*yy_bp;
register char *yy_cp, *yy_bp;
register int yy_act;
#line 179 "scan.l"
#line 827 "lex.yy.c"
#line 828 "lex.yy.c"
if (yy_init)
if ( yy_init )
{
yy_init = 0;
......@@ -859,32 +834,31 @@ YY_DECL
YY_USER_INIT;
#endif
if (!yy_start)
if ( ! yy_start )
yy_start = 1; /* first start state */
if (!yyin)
if ( ! yyin )
yyin = stdin;
if (!yyout)
if ( ! yyout )
yyout = stdout;
if (!yy_current_buffer)
if ( ! yy_current_buffer )
yy_current_buffer =
yy_create_buffer(yyin, YY_BUF_SIZE);
yy_create_buffer( yyin, YY_BUF_SIZE );
yy_load_buffer_state();
}
while (1) /* loops until end-of-file is reached */
while ( 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 points to the position in yy_ch_buf of the start of
* the current run.
*/
yy_bp = yy_cp;
......@@ -895,39 +869,38 @@ yy_match:
do
{
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
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 >= 134)
if ( yy_current_state >= 134 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
*yy_state_ptr++ = yy_current_state;
++yy_cp;
}
while (yy_base[yy_current_state] != 451);
while ( yy_base[yy_current_state] != 451 );
yy_find_action:
yy_current_state = *--yy_state_ptr;
yy_lp = yy_accept[yy_current_state];
find_rule: /* we branch to this label when backing up */
for (;;) /* until we find what rule we matched */
for ( ; ; ) /* until we find what rule we matched */
{
if (yy_lp && yy_lp < yy_accept[yy_current_state + 1])
if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
{
yy_act = yy_acclist[yy_lp];
if (yy_act & YY_TRAILING_HEAD_MASK ||
yy_looking_for_trail_begin)
if ( yy_act & YY_TRAILING_HEAD_MASK ||
yy_looking_for_trail_begin )
{
if (yy_act == yy_looking_for_trail_begin)
if ( yy_act == yy_looking_for_trail_begin )
{
yy_looking_for_trail_begin = 0;
yy_act &= ~YY_TRAILING_HEAD_MASK;
break;
}
}
else if (yy_act & YY_TRAILING_MASK)
else if ( yy_act & YY_TRAILING_MASK )
{
yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;
yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;
......@@ -950,399 +923,397 @@ find_rule: /* we branch to this label when backing up */
YY_DO_BEFORE_ACTION;
do_action: /* This label is used only to access EOF
* actions. */
do_action: /* This label is used only to access EOF actions. */
switch (yy_act)
switch ( yy_act )
{ /* beginning of action switch */
case 1:
YY_RULE_SETUP
case 1:
YY_RULE_SETUP
#line 180 "scan.l"
{ /* ignore */
}
{ /* ignore */ }
YY_BREAK
case 2:
YY_RULE_SETUP
case 2:
YY_RULE_SETUP
#line 182 "scan.l"
{ /* ignore */
}
{ /* ignore */ }
YY_BREAK
case 3:
case 3:
#line 185 "scan.l"
case 4:
YY_RULE_SETUP
case 4:
YY_RULE_SETUP
#line 185 "scan.l"
BEGIN(xc);
{ BEGIN(xc); }
YY_BREAK
case 5:
YY_RULE_SETUP
case 5:
YY_RULE_SETUP
#line 187 "scan.l"
BEGIN(INITIAL);
{ BEGIN(INITIAL); }
YY_BREAK
case 6:
YY_RULE_SETUP
case 6:
YY_RULE_SETUP
#line 189 "scan.l"
{ /* ignore */
}
{ /* ignore */ }
YY_BREAK
case 7:
YY_RULE_SETUP
case 7:
YY_RULE_SETUP
#line 191 "scan.l"
{
{
BEGIN(xb);
llen = 0;
*literal = '\0';
}
YY_BREAK
case 8:
YY_RULE_SETUP
case 8:
YY_RULE_SETUP
#line 196 "scan.l"
{
char *endptr;
{
char* endptr;
BEGIN(INITIAL);
errno = 0;
yylval.ival = strtol((char *) literal, &endptr, 2);
yylval.ival = strtol((char *)literal,&endptr,2);
if (*endptr != '\0' || errno == ERANGE)
elog(ERROR, "Bad binary integer input '%s'", literal);
elog(ERROR,"Bad binary integer input '%s'",literal);
return ICONST;
}
YY_BREAK
case 9:
case 9:
#line 207 "scan.l"
case 10:
YY_RULE_SETUP
case 10:
YY_RULE_SETUP
#line 207 "scan.l"
{
if ((llen + yyleng) > (MAX_PARSE_BUFFER - 1))
elog(ERROR, "quoted string parse buffer of %d chars exceeded", MAX_PARSE_BUFFER);
memcpy(literal + llen, yytext, yyleng + 1);
{
if ((llen+yyleng) > (MAX_PARSE_BUFFER - 1))
elog(ERROR,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
memcpy(literal+llen, yytext, yyleng+1);
llen += yyleng;
}
YY_BREAK
case 11:
case 11:
#line 214 "scan.l"
case 12:
YY_RULE_SETUP
case 12:
YY_RULE_SETUP
#line 214 "scan.l"
{
{
}
YY_BREAK
case 13:
YY_RULE_SETUP
case 13:
YY_RULE_SETUP
#line 217 "scan.l"
{
{
BEGIN(xh);
llen = 0;
*literal = '\0';
}
YY_BREAK
case 14:
YY_RULE_SETUP
case 14:
YY_RULE_SETUP
#line 222 "scan.l"
{
char *endptr;
{
char* endptr;
BEGIN(INITIAL);
errno = 0;
yylval.ival = strtol((char *) literal, &endptr, 16);
yylval.ival = strtol((char *)literal,&endptr,16);
if (*endptr != '\0' || errno == ERANGE)
elog(ERROR, "Bad hexadecimal integer input '%s'", literal);
elog(ERROR,"Bad hexadecimal integer input '%s'",literal);
return ICONST;
}
YY_BREAK
case 15:
YY_RULE_SETUP
case 15:
YY_RULE_SETUP
#line 233 "scan.l"
{
{
BEGIN(xq);
llen = 0;
*literal = '\0';
}
YY_BREAK
case 16:
YY_RULE_SETUP
case 16:
YY_RULE_SETUP
#line 238 "scan.l"
{
{
BEGIN(INITIAL);
yylval.str = pstrdup(scanstr(literal));
return SCONST;
}
YY_BREAK
case 17:
case 17:
#line 244 "scan.l"
case 18:
YY_RULE_SETUP
case 18:
YY_RULE_SETUP
#line 244 "scan.l"
{
if ((llen + yyleng) > (MAX_PARSE_BUFFER - 1))
elog(ERROR, "quoted string parse buffer of %d chars exceeded", MAX_PARSE_BUFFER);
memcpy(literal + llen, yytext, yyleng + 1);
{
if ((llen+yyleng) > (MAX_PARSE_BUFFER - 1))
elog(ERROR,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
memcpy(literal+llen, yytext, yyleng+1);
llen += yyleng;
}
YY_BREAK
case 19:
YY_RULE_SETUP
case 19:
YY_RULE_SETUP
#line 250 "scan.l"
{
if ((llen + yyleng - 1) > (MAX_PARSE_BUFFER - 1))
elog(ERROR, "quoted string parse buffer of %d chars exceeded", MAX_PARSE_BUFFER);
memcpy(literal + llen, yytext, yyleng + 1);
*(literal + llen) = '\'';
{
if ((llen+yyleng-1) > (MAX_PARSE_BUFFER - 1))
elog(ERROR,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
memcpy(literal+llen, yytext, yyleng+1);
*(literal+llen) = '\'';
llen += yyleng;
}
YY_BREAK
case 20:
YY_RULE_SETUP
case 20:
YY_RULE_SETUP
#line 258 "scan.l"
{
if ((llen + yyleng - 1) > (MAX_PARSE_BUFFER - 1))
elog(ERROR, "quoted string parse buffer of %d chars exceeded", MAX_PARSE_BUFFER);
memcpy(literal + llen, yytext, yyleng + 1);
{
if ((llen+yyleng-1) > (MAX_PARSE_BUFFER - 1))
elog(ERROR,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
memcpy(literal+llen, yytext, yyleng+1);
llen += yyleng;
}
YY_BREAK
case 21:
YY_RULE_SETUP
case 21:
YY_RULE_SETUP
#line 264 "scan.l"
{
{
}
YY_BREAK
case 22:
YY_RULE_SETUP
case 22:
YY_RULE_SETUP
#line 268 "scan.l"
{
{
BEGIN(xd);
llen = 0;
*literal = '\0';
}
YY_BREAK
case 23:
YY_RULE_SETUP
case 23:
YY_RULE_SETUP
#line 273 "scan.l"
{
{
BEGIN(INITIAL);
yylval.str = pstrdup(literal);
return IDENT;
}
YY_BREAK
case 24:
YY_RULE_SETUP
case 24:
YY_RULE_SETUP
#line 278 "scan.l"
{
if ((llen + yyleng) > (MAX_PARSE_BUFFER - 1))
elog(ERROR, "quoted string parse buffer of %d chars exceeded", MAX_PARSE_BUFFER);
memcpy(literal + llen, yytext, yyleng + 1);
{
if ((llen+yyleng) > (MAX_PARSE_BUFFER - 1))
elog(ERROR,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
memcpy(literal+llen, yytext, yyleng+1);
llen += yyleng;
}
YY_BREAK
case 25:
YY_RULE_SETUP
case 25:
YY_RULE_SETUP
#line 286 "scan.l"
{ /* ignore */
}
{ /* ignore */ }
YY_BREAK
case 26:
YY_RULE_SETUP
case 26:
YY_RULE_SETUP
#line 287 "scan.l"
{
{
BEGIN(INITIAL);
return yytext[0];
}
YY_BREAK
case 27:
YY_RULE_SETUP
case 27:
YY_RULE_SETUP
#line 293 "scan.l"
return TYPECAST;
{ return TYPECAST; }
YY_BREAK
case 28:
*yy_cp = yy_hold_char; /* undo effects of setting up
* yytext */
yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
case 28:
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
#line 295 "scan.l"
{
{
BEGIN(xm);
return yytext[0];
}
YY_BREAK
case 29:
YY_RULE_SETUP
case 29:
YY_RULE_SETUP
#line 299 "scan.l"
return yytext[0];
return yytext[0];
{ return yytext[0]; }
YY_BREAK
case 30:
*yy_cp = yy_hold_char; /* undo effects of setting up
* yytext */
yy_c_buf_p = yy_cp -= 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
case 30:
YY_RULE_SETUP
#line 300 "scan.l"
{
yylval.str = pstrdup((char *) yytext);
{ return yytext[0]; }
YY_BREAK
case 31:
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
yy_c_buf_p = yy_cp -= 2;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
#line 301 "scan.l"
{
yylval.str = pstrdup((char*)yytext);
return Op;
}
YY_BREAK
case 31:
YY_RULE_SETUP
#line 304 "scan.l"
{
if (strcmp((char *) yytext, "!=") == 0)
case 32:
YY_RULE_SETUP
#line 305 "scan.l"
{
if (strcmp((char*)yytext,"!=") == 0)
yylval.str = pstrdup("<>"); /* compatability */
else
yylval.str = pstrdup((char *) yytext);
yylval.str = pstrdup((char*)yytext);
return Op;
}
YY_BREAK
case 32:
YY_RULE_SETUP
#line 311 "scan.l"
{
yylval.ival = atoi((char *) &yytext[1]);
case 33:
YY_RULE_SETUP
#line 312 "scan.l"
{
yylval.ival = atoi((char*)&yytext[1]);
return PARAM;
}
YY_BREAK
case 33:
YY_RULE_SETUP
#line 317 "scan.l"
{
case 34:
YY_RULE_SETUP
#line 318 "scan.l"
{
int i;
ScanKeyword *keyword;
BEGIN(xm);
for (i = 0; yytext[i]; i++)
if (isascii((unsigned char) yytext[i]) &&
for(i = 0; yytext[i]; i++)
if (isascii((unsigned char)yytext[i]) &&
isupper(yytext[i]))
yytext[i] = tolower(yytext[i]);
if (i >= NAMEDATALEN)
yytext[NAMEDATALEN - 1] = '\0';
yytext[NAMEDATALEN-1] = '\0';
keyword = ScanKeywordLookup((char *) yytext);
if (keyword != NULL)
keyword = ScanKeywordLookup((char*)yytext);
if (keyword != NULL) {
return keyword->value;
}
else
{
yylval.str = pstrdup((char *) yytext);
yylval.str = pstrdup((char*)yytext);
return IDENT;
}
}
YY_BREAK
case 34:
YY_RULE_SETUP
#line 339 "scan.l"
{
char *endptr;
case 35:
YY_RULE_SETUP
#line 340 "scan.l"
{
char* endptr;
BEGIN(xm);
errno = 0;
yylval.ival = strtol((char *) yytext, &endptr, 10);
yylval.ival = strtol((char *)yytext,&endptr,10);
if (*endptr != '\0' || errno == ERANGE)
{
errno = 0;
yylval.dval = strtod(((char *) yytext), &endptr);
yylval.dval = strtod(((char *)yytext),&endptr);
if (*endptr != '\0' || errno == ERANGE)
elog(ERROR, "Bad integer input '%s'", yytext);
elog(ERROR,"Bad integer input '%s'",yytext);
CheckFloat8Val(yylval.dval);
elog(NOTICE, "Integer input '%s' is out of range; promoted to float", yytext);
elog(NOTICE,"Integer input '%s' is out of range; promoted to float", yytext);
return FCONST;
}
return ICONST;
}
YY_BREAK
case 35:
YY_RULE_SETUP
#line 357 "scan.l"
{
char *endptr;
case 36:
YY_RULE_SETUP
#line 358 "scan.l"
{
char* endptr;
BEGIN(xm);
errno = 0;
yylval.dval = strtod(((char *) yytext), &endptr);
yylval.dval = strtod(((char *)yytext),&endptr);
if (*endptr != '\0' || errno == ERANGE)
elog(ERROR, "Bad float8 input '%s'", yytext);
elog(ERROR,"Bad float8 input '%s'",yytext);
CheckFloat8Val(yylval.dval);
return FCONST;
}
YY_BREAK
case 36:
YY_RULE_SETUP
#line 368 "scan.l"
{
char *endptr;
case 37:
YY_RULE_SETUP
#line 369 "scan.l"
{
char* endptr;
errno = 0;
yylval.ival = strtol((char *) yytext, &endptr, 10);
yylval.ival = strtol((char *)yytext,&endptr,10);
if (*endptr != '\0' || errno == ERANGE)
{
errno = 0;
yylval.dval = strtod(((char *) yytext), &endptr);
yylval.dval = strtod(((char *)yytext),&endptr);
if (*endptr != '\0' || errno == ERANGE)
elog(ERROR, "Bad integer input '%s'", yytext);
elog(ERROR,"Bad integer input '%s'",yytext);
CheckFloat8Val(yylval.dval);
elog(NOTICE, "Integer input '%s' is out of range; promoted to float", yytext);
elog(NOTICE,"Integer input '%s' is out of range; promoted to float", yytext);
return FCONST;
}
return ICONST;
}
YY_BREAK
case 37:
YY_RULE_SETUP
#line 385 "scan.l"
{
char *endptr;
case 38:
YY_RULE_SETUP
#line 386 "scan.l"
{
char* endptr;
errno = 0;
yylval.dval = strtod((char *) yytext, &endptr);
yylval.dval = strtod((char *)yytext,&endptr);
if (*endptr != '\0' || errno == ERANGE)
elog(ERROR, "Bad float input '%s'", yytext);
elog(ERROR,"Bad float input '%s'",yytext);
CheckFloat8Val(yylval.dval);
return FCONST;
}
YY_BREAK
case 38:
YY_RULE_SETUP
#line 397 "scan.l"
{
case 39:
YY_RULE_SETUP
#line 398 "scan.l"
{
int i;
ScanKeyword *keyword;
for (i = 0; yytext[i]; i++)
if (isascii((unsigned char) yytext[i]) &&
for(i = 0; yytext[i]; i++)
if (isascii((unsigned char)yytext[i]) &&
isupper(yytext[i]))
yytext[i] = tolower(yytext[i]);
if (i >= NAMEDATALEN)
yytext[NAMEDATALEN - 1] = '\0';
yytext[NAMEDATALEN-1] = '\0';
keyword = ScanKeywordLookup((char *) yytext);
if (keyword != NULL)
keyword = ScanKeywordLookup((char*)yytext);
if (keyword != NULL) {
return keyword->value;
}
else
{
yylval.str = pstrdup((char *) yytext);
yylval.str = pstrdup((char*)yytext);
return IDENT;
}
}
YY_BREAK
case 39:
YY_RULE_SETUP
#line 418 "scan.l"
{ /* ignore */
}
case 40:
YY_RULE_SETUP
#line 419 "scan.l"
{ /* ignore */ }
YY_BREAK
case 40:
YY_RULE_SETUP
#line 420 "scan.l"
return (yytext[0]);
case 41:
YY_RULE_SETUP
#line 421 "scan.l"
{ return yytext[0]; }
YY_BREAK
case 41:
YY_RULE_SETUP
#line 422 "scan.l"
ECHO;
case 42:
YY_RULE_SETUP
#line 423 "scan.l"
ECHO;
YY_BREAK
#line 1311 "lex.yy.c"
#line 1317 "lex.yy.c"
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(xb):
case YY_STATE_EOF(xc):
......@@ -1361,34 +1332,30 @@ do_action: /* This label is used only to access EOF
*yy_cp = yy_hold_char;
YY_RESTORE_YY_MORE_OFFSET
if (yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW)
if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
{
/*
* We're scanning a new file or input source. It's
/* 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.
* 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->yy_n_chars;
yy_current_buffer->yy_input_file = yyin;
yy_current_buffer->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().
/* 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->yy_ch_buf[yy_n_chars])
if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
{ /* This was really a NUL. */
yy_state_type yy_next_state;
......@@ -1396,21 +1363,20 @@ do_action: /* This label is used only to access EOF
yy_current_state = yy_get_previous_state();
/*
* Okay, we're now positioned to make the NUL
/* 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_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_next_state = yy_try_NUL_trans( yy_current_state );
yy_bp = yytext_ptr + YY_MORE_ADJ;
if (yy_next_state)
if ( yy_next_state )
{
/* Consume the NUL. */
yy_cp = ++yy_c_buf_p;
......@@ -1425,26 +1391,22 @@ do_action: /* This label is used only to access EOF
}
}
else
switch (yy_get_next_buffer())
else switch ( yy_get_next_buffer() )
{
case EOB_ACT_END_OF_FILE:
{
yy_did_buffer_switch_on_eof = 0;
if (yywrap())
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.
/* 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;
......@@ -1454,7 +1416,7 @@ do_action: /* This label is used only to access EOF
else
{
if (!yy_did_buffer_switch_on_eof)
if ( ! yy_did_buffer_switch_on_eof )
YY_NEW_FILE;
}
break;
......@@ -1485,10 +1447,10 @@ do_action: /* This label is used only to access EOF
default:
YY_FATAL_ERROR(
"fatal flex scanner internal error--no action found");
"fatal flex scanner internal error--no action found" );
} /* end of action switch */
} /* end of scanning one token */
} /* end of yylex */
} /* end of yylex */
/* yy_get_next_buffer - try to read in a new buffer
......@@ -1499,37 +1461,31 @@ do_action: /* This label is used only to access EOF
* EOB_ACT_END_OF_FILE - end of file
*/
static int
yy_get_next_buffer()
{
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;
register int number_to_move, i;
int ret_val;
if (yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1])
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");
"fatal flex scanner internal error--end of buffer missed" );
if (yy_current_buffer->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)
if ( yy_current_buffer->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.
/* 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.
/* We matched some text prior to the EOB, first
* process it.
*/
return EOB_ACT_LAST_MATCH;
}
......@@ -1540,14 +1496,12 @@ yy_get_next_buffer()
/* 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)
for ( i = 0; i < number_to_move; ++i )
*(dest++) = *(source++);
if (yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING)
/*
* don't do the read, it's not guaranteed to return an EOF, just
* force an EOF
if ( yy_current_buffer->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->yy_n_chars = yy_n_chars = 0;
......@@ -1556,12 +1510,11 @@ yy_get_next_buffer()
int num_to_read =
yy_current_buffer->yy_buf_size - number_to_move - 1;
while (num_to_read <= 0)
{ /* Not enough room in the buffer - grow
* it. */
while ( num_to_read <= 0 )
{ /* Not enough room in the buffer - grow it. */
#ifdef YY_USES_REJECT
YY_FATAL_ERROR(
"input buffer overflow, can't enlarge buffer because scanner uses REJECT");
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
#else
/* just a shorter name for the current buffer */
......@@ -1570,27 +1523,27 @@ yy_get_next_buffer()
int yy_c_buf_p_offset =
(int) (yy_c_buf_p - b->yy_ch_buf);
if (b->yy_is_our_buffer)
if ( b->yy_is_our_buffer )
{
int new_size = b->yy_buf_size * 2;
if (new_size <= 0)
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. */
yy_flex_realloc((void *) b->yy_ch_buf,
b->yy_buf_size + 2);
yy_flex_realloc( (void *) b->yy_ch_buf,
b->yy_buf_size + 2 );
}
else
/* Can't grow it, we don't own it. */
b->yy_ch_buf = 0;
if (!b->yy_ch_buf)
if ( ! b->yy_ch_buf )
YY_FATAL_ERROR(
"fatal error - scanner input buffer overflow");
"fatal error - scanner input buffer overflow" );
yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
......@@ -1599,22 +1552,22 @@ yy_get_next_buffer()
#endif
}
if (num_to_read > YY_READ_BUF_SIZE)
if ( num_to_read > YY_READ_BUF_SIZE )
num_to_read = YY_READ_BUF_SIZE;
/* Read in more data. */
YY_INPUT((&yy_current_buffer->yy_ch_buf[number_to_move]),
yy_n_chars, num_to_read);
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 ( yy_n_chars == 0 )
{
if (number_to_move == YY_MORE_ADJ)
if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
yyrestart(yyin);
yyrestart( yyin );
}
else
......@@ -1635,14 +1588,13 @@ yy_get_next_buffer()
yytext_ptr = &yy_current_buffer->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()
{
static yy_state_type yy_get_previous_state()
{
register yy_state_type yy_current_state;
register char *yy_cp;
......@@ -1650,14 +1602,13 @@ yy_get_previous_state()
yy_state_ptr = yy_state_buf;
*yy_state_ptr++ = yy_current_state;
for (yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp)
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);
while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
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 >= 134)
if ( yy_current_state >= 134 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
......@@ -1665,7 +1616,7 @@ yy_get_previous_state()
}
return yy_current_state;
}
}
/* yy_try_NUL_trans - try to make a transition on the NUL character
......@@ -1675,52 +1626,45 @@ yy_get_previous_state()
*/
#ifdef YY_USE_PROTOS
static yy_state_type
yy_try_NUL_trans(yy_state_type yy_current_state)
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)
static yy_state_type yy_try_NUL_trans( yy_current_state )
yy_state_type yy_current_state;
#endif
{
{
register int yy_is_jam;
register YY_CHAR yy_c = 1;
while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
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 >= 134)
if ( yy_current_state >= 134 )
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 == 133);
if (!yy_is_jam)
if ( ! yy_is_jam )
*yy_state_ptr++ = yy_current_state;
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)
static void yyunput( int c, register char *yy_bp )
#else
static void
yyunput(c, yy_bp)
static void yyunput( c, yy_bp )
int c;
register char *yy_bp;
#endif
{
{
register char *yy_cp = yy_c_buf_p;
/* undo effects of setting up yytext */
*yy_cp = yy_hold_char;
if (yy_cp < yy_current_buffer->yy_ch_buf + 2)
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
{ /* need to shift things up to make room */
/* +2 for EOB chars. */
register int number_to_move = yy_n_chars + 2;
......@@ -1729,7 +1673,7 @@ register char *yy_bp;
register char *source =
&yy_current_buffer->yy_ch_buf[number_to_move];
while (source > yy_current_buffer->yy_ch_buf)
while ( source > yy_current_buffer->yy_ch_buf )
*--dest = *--source;
yy_cp += (int) (dest - source);
......@@ -1737,8 +1681,8 @@ register char *yy_bp;
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");
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
YY_FATAL_ERROR( "flex scanner push-back overflow" );
}
*--yy_cp = (char) c;
......@@ -1747,65 +1691,59 @@ register char *yy_bp;
yytext_ptr = yy_bp;
yy_hold_char = *yy_cp;
yy_c_buf_p = yy_cp;
}
}
#endif /* ifndef YY_NO_UNPUT */
#ifdef __cplusplus
static int
yyinput()
static int yyinput()
#else
static int
input()
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_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.
/* 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->yy_ch_buf[yy_n_chars])
if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
/* This was really a NUL. */
*yy_c_buf_p = '\0';
else
{ /* need more input */
int offset = yy_c_buf_p - yytext_ptr;
++yy_c_buf_p;
switch (yy_get_next_buffer())
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.
/* 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);
yyrestart( yyin );
/* fall through */
case EOB_ACT_END_OF_FILE:
{
if (yywrap())
if ( yywrap() )
return EOF;
if (!yy_did_buffer_switch_on_eof)
if ( ! yy_did_buffer_switch_on_eof )
YY_NEW_FILE;
#ifdef __cplusplus
return yyinput();
......@@ -1827,41 +1765,35 @@ input()
return c;
}
}
#ifdef YY_USE_PROTOS
void
yyrestart(FILE *input_file)
void yyrestart( FILE *input_file )
#else
void
yyrestart(input_file)
void yyrestart( input_file )
FILE *input_file;
#endif
{
if (!yy_current_buffer)
yy_current_buffer = yy_create_buffer(yyin, YY_BUF_SIZE);
{
if ( ! yy_current_buffer )
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
yy_init_buffer(yy_current_buffer, input_file);
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)
void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
#else
void
yy_switch_to_buffer(new_buffer)
void yy_switch_to_buffer( new_buffer )
YY_BUFFER_STATE new_buffer;
#endif
{
if (yy_current_buffer == new_buffer)
{
if ( yy_current_buffer == new_buffer )
return;
if (yy_current_buffer)
if ( yy_current_buffer )
{
/* Flush out information for old buffer. */
*yy_c_buf_p = yy_hold_char;
......@@ -1872,110 +1804,96 @@ YY_BUFFER_STATE new_buffer;
yy_current_buffer = 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.
/* 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;
}
}
#ifdef YY_USE_PROTOS
void
yy_load_buffer_state(void)
void yy_load_buffer_state( void )
#else
void
yy_load_buffer_state()
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)
YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
#else
YY_BUFFER_STATE
yy_create_buffer(file, size)
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_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;
/*
* yy_ch_buf has to be 2 characters longer than the size given because
/* 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 *) 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_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);
yy_init_buffer( b, file );
return b;
}
}
#ifdef YY_USE_PROTOS
void
yy_delete_buffer(YY_BUFFER_STATE b)
void yy_delete_buffer( YY_BUFFER_STATE b )
#else
void
yy_delete_buffer(b)
void yy_delete_buffer( b )
YY_BUFFER_STATE b;
#endif
{
if (!b)
{
if ( ! b )
return;
if (b == yy_current_buffer)
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);
if ( b->yy_is_our_buffer )
yy_flex_free( (void *) b->yy_ch_buf );
yy_flex_free((void *) b);
}
yy_flex_free( (void *) b );
}
#ifndef YY_ALWAYS_INTERACTIVE
#ifndef YY_NEVER_INTERACTIVE
extern int isatty YY_PROTO((int));
extern int isatty YY_PROTO(( int ));
#endif
#endif
#ifdef YY_USE_PROTOS
void
yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
#else
void
yy_init_buffer(b, file)
void yy_init_buffer( b, file )
YY_BUFFER_STATE b;
FILE *file;
#endif
{
yy_flush_buffer(b);
{
yy_flush_buffer( b );
b->yy_input_file = file;
b->yy_fill_buffer = 1;
......@@ -1986,32 +1904,28 @@ FILE *file;
#if YY_NEVER_INTERACTIVE
b->yy_is_interactive = 0;
#else
b->yy_is_interactive = file ? (isatty(fileno(file)) > 0) : 0;
b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
#endif
#endif
}
}
#ifdef YY_USE_PROTOS
void
yy_flush_buffer(YY_BUFFER_STATE b)
void yy_flush_buffer( YY_BUFFER_STATE b )
#else
void
yy_flush_buffer(b)
void yy_flush_buffer( b )
YY_BUFFER_STATE b;
#endif
{
if (!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.
/* 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;
......@@ -2021,34 +1935,31 @@ YY_BUFFER_STATE b;
b->yy_at_bol = 1;
b->yy_buffer_status = YY_BUFFER_NEW;
if (b == yy_current_buffer)
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)
YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
#else
YY_BUFFER_STATE
yy_scan_buffer(base, size)
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)
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 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_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; /* "- 2" to take care of EOB's */
b->yy_buf_pos = b->yy_ch_buf = base;
......@@ -2060,48 +1971,39 @@ yy_size_t size;
b->yy_fill_buffer = 0;
b->yy_buffer_status = YY_BUFFER_NEW;
yy_switch_to_buffer(b);
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)
YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
#else
YY_BUFFER_STATE
yy_scan_string(yy_str)
YY_BUFFER_STATE yy_scan_string( yy_str )
yyconst char *yy_str;
#endif
{
{
int len;
for (len = 0; yy_str[len]; ++len)
for ( len = 0; yy_str[len]; ++len )
;
return yy_scan_bytes(yy_str, 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)
YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
#else
YY_BUFFER_STATE
yy_scan_bytes(bytes, len)
YY_BUFFER_STATE yy_scan_bytes( bytes, len )
yyconst char *bytes;
int len;
#endif
{
{
YY_BUFFER_STATE b;
char *buf;
yy_size_t n;
......@@ -2109,89 +2011,79 @@ int len;
/* Get memory for full buffer, including space for trailing EOB's. */
n = len + 2;
buf = (char *) yy_flex_alloc(n);
if (!buf)
YY_FATAL_ERROR("out of dynamic memory in yy_scan_bytes()");
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)
for ( i = 0; i < len; ++i )
buf[i] = bytes[i];
buf[len] = buf[len + 1] = YY_END_OF_BUFFER_CHAR;
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_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.
/* 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;
}
}
#endif
#ifndef YY_NO_PUSH_STATE
#ifdef YY_USE_PROTOS
static void
yy_push_state(int new_state)
static void yy_push_state( int new_state )
#else
static void
yy_push_state(new_state)
static void yy_push_state( new_state )
int new_state;
#endif
{
if (yy_start_stack_ptr >= yy_start_stack_depth)
{
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);
new_size = yy_start_stack_depth * sizeof( int );
if (!yy_start_stack)
yy_start_stack = (int *) yy_flex_alloc(new_size);
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);
(void *) yy_start_stack, new_size );
if (!yy_start_stack)
if ( ! yy_start_stack )
YY_FATAL_ERROR(
"out of memory expanding start-condition stack");
"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");
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()
{
static int yy_top_state()
{
return yy_start_stack[yy_start_stack_ptr - 1];
}
}
#endif
#ifndef YY_EXIT_FAILURE
......@@ -2199,18 +2091,15 @@ yy_top_state()
#endif
#ifdef YY_USE_PROTOS
static void
yy_fatal_error(yyconst char msg[])
static void yy_fatal_error( yyconst char msg[] )
#else
static void
yy_fatal_error(msg)
static void yy_fatal_error( msg )
char msg[];
#endif
{
(void) fprintf(stderr, "%s\n", msg);
exit(YY_EXIT_FAILURE);
}
{
(void) fprintf( stderr, "%s\n", msg );
exit( YY_EXIT_FAILURE );
}
......@@ -2234,117 +2123,93 @@ char msg[];
#ifndef yytext_ptr
#ifdef YY_USE_PROTOS
static void
yy_flex_strncpy(char *s1, yyconst char *s2, int n)
static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
#else
static void
yy_flex_strncpy(s1, s2, n)
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)
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)
static int yy_flex_strlen( yyconst char *s )
#else
static int
yy_flex_strlen(s)
static int yy_flex_strlen( s )
yyconst char *s;
#endif
{
{
register int n;
for (n = 0; s[n]; ++n)
for ( n = 0; s[n]; ++n )
;
return n;
}
}
#endif
#ifdef YY_USE_PROTOS
static void *
yy_flex_alloc(yy_size_t size)
static void *yy_flex_alloc( yy_size_t size )
#else
static void *
yy_flex_alloc(size)
static void *yy_flex_alloc( size )
yy_size_t size;
#endif
{
return (void *) malloc(size);
}
{
return (void *) malloc( size );
}
#ifdef YY_USE_PROTOS
static void *
yy_flex_realloc(void *ptr, yy_size_t size)
static void *yy_flex_realloc( void *ptr, yy_size_t size )
#else
static void *
yy_flex_realloc(ptr, size)
static void *yy_flex_realloc( ptr, size )
void *ptr;
yy_size_t size;
#endif
{
/*
* 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.
{
/* 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 (void *) realloc((char *) ptr, size);
}
return (void *) realloc( (char *) ptr, size );
}
#ifdef YY_USE_PROTOS
static void
yy_flex_free(void *ptr)
static void yy_flex_free( void *ptr )
#else
static void
yy_flex_free(ptr)
static void yy_flex_free( ptr )
void *ptr;
#endif
{
free(ptr);
}
{
free( ptr );
}
#if YY_MAIN
int
main()
{
int main()
{
yylex();
return 0;
}
}
#endif
#line 422 "scan.l"
#line 423 "scan.l"
void
yyerror(char message[])
void yyerror(char message[])
{
elog(ERROR, "parser: %s at or near \"%s\"", message, yytext);
}
int
yywrap()
int yywrap()
{
return (1);
return(1);
}
/*
......@@ -2354,12 +2219,9 @@ yywrap()
void
init_io()
{
/*
* it's important to set this to NULL because input()/myinput() checks
* the non-nullness of parseCh to know when to pass the string to
* lex/flex
*/
/* it's important to set this to NULL
because input()/myinput() checks the non-nullness of parseCh
to know when to pass the string to lex/flex */
parseCh = NULL;
#if defined(FLEX_SCANNER)
if (YY_CURRENT_BUFFER)
......@@ -2376,12 +2238,12 @@ input()
if (parseCh == NULL)
{
parseCh = parseString;
return (*parseCh++);
return(*parseCh++);
}
else if (*parseCh == '\0')
return (0);
return(0);
else
return (*parseCh++);
return(*parseCh++);
}
/* undo lex input from a string instead of from stdin */
......@@ -2393,16 +2255,14 @@ unput(char c)
else if (c != 0)
*--parseCh = c;
}
#endif /* !defined(FLEX_SCANNER) */
#ifdef FLEX_SCANNER
/* input routine for flex to read input from a string instead of a file */
int
myinput(char *buf, int max)
myinput(char* buf, int max)
{
int len,
copylen;
int len, copylen;
if (parseCh == NULL)
{
......@@ -2420,5 +2280,5 @@ myinput(char *buf, int max)
else
return 0; /* end of string */
}
#endif /* FLEX_SCANNER */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment