opensourcemirror
/
postgresql
mirror of git://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Lex/yacc source cleanup like indent.

This commit is contained in:
Bruce Momjian 1997-09-08 03:20:18 +00:00
parent 319dbfa736
commit 23db70bf73
5 changed files with 2636 additions and 2625 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

410
src/backend/bootstrap/bootparse.y
View File

@ -2,13 +2,13 @@
/*-------------------------------------------------------------------------
*
* backendparse.y--
* yacc parser grammer for the "backend" initialization program.
* yacc parser grammer for the "backend" initialization program.
*
* Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v 1.4 1996/11/13 20:47:45 scrappy Exp $
* $Header: /cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v 1.5 1997/09/08 03:19:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -16,11 +16,11 @@
#include "postgres.h"
#include "catalog/pg_attribute.h"
#include "access/attnum.h"
#include "access/attnum.h"
#include "nodes/pg_list.h"
#include "access/tupdesc.h"
#include "access/tupdesc.h"
#include "storage/fd.h"
#include "catalog/pg_am.h"
#include "catalog/pg_am.h"
#include "catalog/pg_class.h"
#include "nodes/nodes.h"
#include "rewrite/prs2lock.h"
@ -57,24 +57,27 @@
#include "miscadmin.h"
#define DO_START { StartTransactionCommand();\
}
#define DO_START { \
StartTransactionCommand();\
}
#define DO_END { CommitTransactionCommand();\
if (!Quiet) { EMITPROMPT; }\
fflush(stdout); \
}
#define DO_END { \
CommitTransactionCommand();\
if (!Quiet) { EMITPROMPT; }\
fflush(stdout); \
}
int num_tuples_read = 0;
static Oid objectid;
%}
%union {
List *list;
IndexElem *ielem;
char *str;
int ival;
%union
{
List *list;
IndexElem *ielem;
char *str;
int ival;
}
%type <list> arg_list
@ -84,7 +87,7 @@ static Oid objectid;
%token <ival> CONST ID
%token OPEN XCLOSE XCREATE INSERT_TUPLE
%token STRING XDEFINE
%token STRING XDEFINE
%token XDECLARE INDEX ON USING XBUILD INDICES
%token COMMA EQUALS LPAREN RPAREN
%token OBJ_ID XBOOTSTRAP NULLVAL
@ -96,228 +99,233 @@ static Oid objectid;
%%
TopLevel:
Queries
|
;
Queries
|
;
Queries:
Query
| Queries Query
;
Query
| Queries Query
;
Query :
OpenStmt
| CloseStmt
| CreateStmt
| InsertStmt
| DeclareIndexStmt
| BuildIndsStmt
;
OpenStmt
| CloseStmt
| CreateStmt
| InsertStmt
| DeclareIndexStmt
| BuildIndsStmt
;
OpenStmt:
OPEN ident
{
DO_START;
boot_openrel(LexIDStr($2));
DO_END;
}
;
OpenStmt:
OPEN ident
{
DO_START;
boot_openrel(LexIDStr($2));
DO_END;
}
;
CloseStmt:
XCLOSE ident %prec low
{
DO_START;
closerel(LexIDStr($2));
DO_END;
}
| XCLOSE %prec high
{
DO_START;
closerel(NULL);
DO_END;
}
;
XCLOSE ident %prec low
{
DO_START;
closerel(LexIDStr($2));
DO_END;
}
| XCLOSE %prec high
{
DO_START;
closerel(NULL);
DO_END;
}
;
CreateStmt:
XCREATE optbootstrap ident LPAREN
{
DO_START;
numattr=(int)0;
}
typelist
{
if (!Quiet) putchar('\n');
DO_END;
}
RPAREN
{
DO_START;
XCREATE optbootstrap ident LPAREN
{
DO_START;
numattr=(int)0;
}
typelist
{
if (!Quiet)
putchar('\n');
DO_END;
}
RPAREN
{
DO_START;
if ($2) {
extern Relation reldesc;
TupleDesc tupdesc;
if ($2)
{
extern Relation reldesc;
TupleDesc tupdesc;
if (reldesc) {
puts("create bootstrap: Warning, open relation");
puts("exists, closing first");
closerel(NULL);
}
if (DebugMode)
puts("creating bootstrap relation");
tupdesc = CreateTupleDesc(numattr,attrtypes);
reldesc = heap_creatr(LexIDStr($3),
DEFAULT_SMGR,
tupdesc);
if (DebugMode)
puts("bootstrap relation created ok");
} else {
Oid id;
TupleDesc tupdesc;
/* extern Oid heap_create();*/
if (reldesc)
{
puts("create bootstrap: Warning, open relation");
puts("exists, closing first");
closerel(NULL);
}
if (DebugMode)
puts("creating bootstrap relation");
tupdesc = CreateTupleDesc(numattr,attrtypes);
reldesc = heap_creatr(LexIDStr($3),
DEFAULT_SMGR,
tupdesc);
if (DebugMode)
puts("bootstrap relation created ok");
}
else
{
Oid id;
TupleDesc tupdesc;
/* extern Oid heap_create();*/
tupdesc = CreateTupleDesc(numattr,attrtypes);
id = heap_create(LexIDStr($3),
NULL,
'n',
DEFAULT_SMGR,
tupdesc);
if (!Quiet)
printf("CREATED relation %s with OID %d\n",
LexIDStr($3), id);
}
DO_END;
if (DebugMode)
puts("Commit End");
}
;
tupdesc = CreateTupleDesc(numattr,attrtypes);
id = heap_create(LexIDStr($3),
NULL,
'n',
DEFAULT_SMGR,
tupdesc);
if (!Quiet)
printf("CREATED relation %s with OID %d\n",
LexIDStr($3), id);
}
DO_END;
if (DebugMode)
puts("Commit End");
}
;
InsertStmt:
INSERT_TUPLE optoideq
{
DO_START;
if (DebugMode)
printf("tuple %d<", $2);
num_tuples_read = 0;
}
LPAREN tuplelist RPAREN
{
if (num_tuples_read != numattr)
elog(WARN,"incorrect number of values for tuple");
if (reldesc == (Relation)NULL) {
elog(WARN,"must OPEN RELATION before INSERT\n");
err_out();
}
if (DebugMode)
puts("Insert Begin");
objectid = $2;
InsertOneTuple(objectid);
if (DebugMode)
puts("Insert End");
if (!Quiet) { putchar('\n'); }
DO_END;
if (DebugMode)
puts("Transaction End");
}
;
INSERT_TUPLE optoideq
{
DO_START;
if (DebugMode)
printf("tuple %d<", $2);
num_tuples_read = 0;
}
LPAREN tuplelist RPAREN
{
if (num_tuples_read != numattr)
elog(WARN,"incorrect number of values for tuple");
if (reldesc == (Relation)NULL)
{
elog(WARN,"must OPEN RELATION before INSERT\n");
err_out();
}
if (DebugMode)
puts("Insert Begin");
objectid = $2;
InsertOneTuple(objectid);
if (DebugMode)
puts("Insert End");
if (!Quiet)
putchar('\n');
DO_END;
if (DebugMode)
puts("Transaction End");
}
;
DeclareIndexStmt:
XDECLARE INDEX ident ON ident USING ident LPAREN index_params RPAREN
{
List *params;
XDECLARE INDEX ident ON ident USING ident LPAREN index_params RPAREN
{
List *params;
DO_START;
DO_START;
params = lappend(NIL, (List*)$9);
DefineIndex(LexIDStr($5),
LexIDStr($3),
LexIDStr($7),
params, NIL, 0, 0, NIL);
DO_END;
}
;
params = lappend(NIL, (List*)$9);
DefineIndex(LexIDStr($5),
LexIDStr($3),
LexIDStr($7),
params, NIL, 0, 0, NIL);
DO_END;
}
;
BuildIndsStmt:
XBUILD INDICES { build_indices(); }
XBUILD INDICES { build_indices(); }
index_params:
index_on ident
{
IndexElem *n = (IndexElem*)$1;
n->class = LexIDStr($2);
$$ = n;
}
index_on ident
{
IndexElem *n = (IndexElem*)$1;
n->class = LexIDStr($2);
$$ = n;
}
index_on:
ident
{
IndexElem *n = makeNode(IndexElem);
n->name = LexIDStr($1);
$$ = n;
}
| ident LPAREN arg_list RPAREN
{
IndexElem *n = makeNode(IndexElem);
n->name = LexIDStr($1);
n->args = (List*)$3;
$$ = n;
}
ident
{
IndexElem *n = makeNode(IndexElem);
n->name = LexIDStr($1);
$$ = n;
}
| ident LPAREN arg_list RPAREN
{
IndexElem *n = makeNode(IndexElem);
n->name = LexIDStr($1);
n->args = (List*)$3;
$$ = n;
}
arg_list:
ident
{
$$ = lappend(NIL, makeString(LexIDStr($1)));
}
| arg_list COMMA ident
{
$$ = lappend((List*)$1, makeString(LexIDStr($3)));
}
ident
{
$$ = lappend(NIL, makeString(LexIDStr($1)));
}
| arg_list COMMA ident
{
$$ = lappend((List*)$1, makeString(LexIDStr($3)));
}
optbootstrap:
XBOOTSTRAP { $$ = 1; }
| { $$ = 0; }
;
XBOOTSTRAP { $$ = 1; }
| { $$ = 0; }
;
typelist:
typething
| typelist COMMA typething
;
typething
| typelist COMMA typething
;
typething:
ident EQUALS ident
{
if(++numattr > MAXATTR)
elog(FATAL,"Too many attributes\n");
DefineAttr(LexIDStr($1),LexIDStr($3),numattr-1);
if (DebugMode)
printf("\n");
}
;
ident EQUALS ident
{
if(++numattr > MAXATTR)
elog(FATAL,"Too many attributes\n");
DefineAttr(LexIDStr($1),LexIDStr($3),numattr-1);
if (DebugMode)
printf("\n");
}
;
optoideq:
OBJ_ID EQUALS ident { $$ = atol(LexIDStr($3)); }
| { extern Oid newoid(); $$ = newoid(); }
;
OBJ_ID EQUALS ident { $$ = atol(LexIDStr($3)); }
| { extern Oid newoid(); $$ = newoid(); }
;
tuplelist:
tuple
| tuplelist tuple
| tuplelist COMMA tuple
;
tuple
| tuplelist tuple
| tuplelist COMMA tuple
;
tuple:
ident {InsertOneValue(objectid, LexIDStr($1), num_tuples_read++); }
| const {InsertOneValue(objectid, LexIDStr($1), num_tuples_read++); }
| NULLVAL
{ InsertOneNull(num_tuples_read++); }
;
ident {InsertOneValue(objectid, LexIDStr($1), num_tuples_read++); }
| const {InsertOneValue(objectid, LexIDStr($1), num_tuples_read++); }
| NULLVAL
{ InsertOneNull(num_tuples_read++); }
;
const :
CONST { $$=yylval.ival; }
;
CONST { $$=yylval.ival; }
;
ident :
ID { $$=yylval.ival; }
;
ID { $$=yylval.ival; }
;
%%

116
src/backend/bootstrap/bootscanner.l
View File

@ -2,13 +2,13 @@
/*-------------------------------------------------------------------------
*
* bootscanner.lex--
* a lexical scanner for the bootstrap parser
* a lexical scanner for the bootstrap parser
*
* Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/bootstrap/bootscanner.l,v 1.6 1997/01/10 20:16:26 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/bootstrap/bootscanner.l,v 1.7 1997/09/08 03:19:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -29,7 +29,7 @@
#include "storage/fd.h"
#include "catalog/pg_am.h"
#include "catalog/pg_class.h"
#include "nodes/nodes.h"
#include "nodes/nodes.h"
#include "rewrite/prs2lock.h"
#include "access/skey.h"
#include "access/strat.h"
@ -38,7 +38,7 @@
#include "nodes/primnodes.h"
#include "utils/nabstime.h"
#include "access/htup.h"
#include "access/htup.h"
#include "utils/tqual.h"
#include "nodes/parsenodes.h"
@ -46,82 +46,82 @@
#include "bootstrap_tokens.h"
#define YY_NO_UNPUT
#define YY_NO_UNPUT
/* some versions of lex define this as a macro */
#if defined(yywrap)
#undef yywrap
#endif /* yywrap */
YYSTYPE yylval;
int yyline; /* keep track of the line number for error reporting */
YYSTYPE yylval;
int yyline; /* keep track of the line number for error reporting */
%}
D [0-9]
oct \\{D}{D}{D}
Exp [Ee][-+]?{D}+
id ([A-Za-z0-9_]|{oct}|\-)+
sid \"([^\"])*\"
arrayid [A-Za-z0-9_]+\[{D}*\]
D [0-9]
oct \\{D}{D}{D}
Exp [Ee][-+]?{D}+
id ([A-Za-z0-9_]|{oct}|\-)+
sid \"([^\"])*\"
arrayid [A-Za-z0-9_]+\[{D}*\]
%%
open { return(OPEN); }
open { return(OPEN); }
close { return(XCLOSE); }
close { return(XCLOSE); }
create { return(XCREATE); }
create { return(XCREATE); }
OID { return(OBJ_ID); }
bootstrap { return(XBOOTSTRAP); }
_null_ { return(NULLVAL); }
OID { return(OBJ_ID); }
bootstrap { return(XBOOTSTRAP); }
_null_ { return(NULLVAL); }
insert { return(INSERT_TUPLE); }
insert { return(INSERT_TUPLE); }
"," { return(COMMA); }
"=" { return(EQUALS); }
"(" { return(LPAREN); }
")" { return(RPAREN); }
"," { return(COMMA); }
"=" { return(EQUALS); }
"(" { return(LPAREN); }
")" { return(RPAREN); }
[\n] { yyline++; }
[\t] ;
" " ;
[\n] { yyline++; }
[\t] ;
" " ;
^\#[^\n]* ; /* drop everything after "#" for comments */
"declare" { return(XDECLARE); }
"build" { return(XBUILD); }
"indices" { return(INDICES); }
"index" { return(INDEX); }
"on" { return(ON); }
"using" { return(USING); }
{arrayid} {
yylval.ival = EnterString(MapArrayTypeName((char*)yytext));
return(ID);
}
{id} {
yylval.ival = EnterString(scanstr((char*)yytext));
return(ID);
}
{sid} {
yytext[strlen(yytext)-1] = '\0'; /* strip off quotes */
yylval.ival = EnterString(scanstr((char*)yytext+1));
yytext[strlen(yytext)] = '"'; /* restore quotes */
return(ID);
}
"declare" { return(XDECLARE); }
"build" { return(XBUILD); }
"indices" { return(INDICES); }
"index" { return(INDEX); }
"on" { return(ON); }
"using" { return(USING); }
{arrayid} {
yylval.ival = EnterString(MapArrayTypeName((char*)yytext));
return(ID);
}
{id} {
yylval.ival = EnterString(scanstr((char*)yytext));
return(ID);
}
{sid} {
yytext[strlen(yytext)-1] = '\0'; /* strip off quotes */
yylval.ival = EnterString(scanstr((char*)yytext+1));
yytext[strlen(yytext)] = '"'; /* restore quotes */
return(ID);
}
(-)?{D}+"."{D}*({Exp})? |
(-)?{D}*"."{D}+({Exp})? |
(-)?{D}+{Exp} {
yylval.ival = EnterString((char*)yytext);
return(CONST);
}
(-)?{D}+"."{D}*({Exp})? |
(-)?{D}*"."{D}+({Exp})? |
(-)?{D}+{Exp} {
yylval.ival = EnterString((char*)yytext);
return(CONST);
}
. {
printf("syntax error %d : -> %s\n", yyline, yytext);
}
. {
printf("syntax error %d : -> %s\n", yyline, yytext);
}
@ -130,11 +130,11 @@ insert { return(INSERT_TUPLE); }
int
yywrap(void)
{
return 1;
return 1;
}
void
yyerror(const char *str)
{
fprintf(stderr,"\tsyntax error %d : %s",yyline, str);
fprintf(stderr,"\tsyntax error %d : %s",yyline, str);
}

4373
src/backend/parser/gram.y
View File

File diff suppressed because it is too large Load Diff

356
src/backend/parser/scan.l
View File

@ -2,13 +2,13 @@
/*-------------------------------------------------------------------------
*
* scan.l--
* lexical scanner for POSTGRES
* lexical scanner for POSTGRES
*
* Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/parser/scan.l,v 1.18 1997/09/05 09:05:48 vadim Exp $
* $Header: /cvsroot/pgsql/src/backend/parser/scan.l,v 1.19 1997/09/08 03:20:04 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@ -64,207 +64,207 @@ int llen;
char literal[MAX_PARSE_BUFFER];
%}
/* OK, here is a short description of lex/flex rules behavior.
* The longest pattern which matches an input string is always chosen.
* For equal-length patterns, the first occurring in the rules list is chosen.
* INITIAL is the starting condition, to which all non-conditional rules apply.
* <xc> is an exclusive condition to allow embedded C-style comments.
* When in an exclusive condition, only those rules defined for that condition apply.
* So, when in condition <xc>, only strings which would terminate the "extended comment"
* trigger any action other than "ignore".
* The "extended comment" syntax closely resembles allowable operator syntax.
* Therefore, be sure to match _any_ candidate comment, including those with appended
* operator-like symbols. - thomas 1997-07-14
*/
/* OK, here is a short description of lex/flex rules behavior.
* The longest pattern which matches an input string is always chosen.
* For equal-length patterns, the first occurring in the rules list is chosen.
* INITIAL is the starting condition, to which all non-conditional rules apply.
* <xc> is an exclusive condition to allow embedded C-style comments.
* When in an exclusive condition, only those rules defined for that condition apply.
* So, when in condition <xc>, only strings which would terminate the "extended comment"
* trigger any action other than "ignore".
* The "extended comment" syntax closely resembles allowable operator syntax.
* Therefore, be sure to match _any_ candidate comment, including those with appended
* operator-like symbols. - thomas 1997-07-14
*/
/* define an exclusive condition to allow extended C-style comments - tgl 1997-07-12 */
/* define an exclusive condition to allow extended C-style comments - tgl 1997-07-12 */
%x xc
/* define an exclusive condition for quoted strings - tgl 1997-07-30 */
/* define an exclusive condition for quoted strings - tgl 1997-07-30 */
%x xq
/* We used to allow double-quoted strings, but SQL doesn't so we won't either */
quote '
xqstart {quote}
xqstop {quote}
xqdouble {quote}{quote}
xqinside [^\']*
xqliteral [\\].
/* We used to allow double-quoted strings, but SQL doesn't so we won't either */
quote '
xqstart {quote}
xqstop {quote}
xqdouble {quote}{quote}
xqinside [^\']*
xqliteral [\\].
xcline [\/][\*].*[\*][\/]{space}*\n*
xcstart [\/][\*]{op_and_self}*
xcstop {op_and_self}*[\*][\/]({space}*|\n)
xcinside [^*]*
xcstar [^/]
xcline [\/][\*].*[\*][\/]{space}*\n*
xcstart [\/][\*]{op_and_self}*
xcstop {op_and_self}*[\*][\/]({space}*|\n)
xcinside [^*]*
xcstar [^/]
digit [0-9]
letter [_A-Za-z]
letter_or_digit [_A-Za-z0-9]
digit [0-9]
letter [_A-Za-z]
letter_or_digit [_A-Za-z0-9]
sysfunc SYS_{letter}{letter_or_digit}*
sysfunc SYS_{letter}{letter_or_digit}*
identifier {letter}{letter_or_digit}*
identifier {letter}{letter_or_digit}*
typecast "::"
typecast "::"
self [,()\[\].;$\:\+\-\*\/\<\>\=\|]
selfm {self}[\-][\.0-9]
self [,()\[\].;$\:\+\-\*\/\<\>\=\|]
selfm {self}[\-][\.0-9]
op_and_self [\~\!\@\#\%\^\&\|\`\?\$\:\+\-\*\/\<\>\=]
op_and_self [\~\!\@\#\%\^\&\|\`\?\$\:\+\-\*\/\<\>\=]
operator {op_and_self}+
operatorm {op_and_self}+[\-][\.0-9]
operator {op_and_self}+
operatorm {op_and_self}+[\-][\.0-9]
integer -?{digit}+
real -?{digit}+\.{digit}+([Ee][-+]?{digit}+)?
integer -?{digit}+
real -?{digit}+\.{digit}+([Ee][-+]?{digit}+)?
param \${integer}
param \${integer}
comment "--".*\n
comment2 "//".*\n
comment "--".*\n
comment2 "//".*\n
space [ \t\n\f]
other .
space [ \t\n\f]
other .
%%
{sysfunc} {
yylval.str = pstrdup(SystemFunctionHandler((char *)yytext));
return (SCONST);
}
{sysfunc} {
yylval.str = pstrdup(SystemFunctionHandler((char *)yytext));
return (SCONST);
}
{comment} { /* ignore */ }
{comment2} { /* ignore */ }
{comment} { /* ignore */ }
{comment2} { /* ignore */ }
{xcline} { /* ignore */ }
{xcline} { /* ignore */ }
<xc>{xcstar} |
{xcstart} { BEGIN(xc); }
{xcstart} { BEGIN(xc); }
<xc>{xcstop} { BEGIN(INITIAL); }
<xc>{xcinside} { /* ignore */ }
{xqstart} {
BEGIN(xq);
llen = 0;
*literal = '\0';
}
BEGIN(xq);
llen = 0;
*literal = '\0';
}
<xq>{xqstop} {
BEGIN(INITIAL);
yylval.str = pstrdup(scanstr(literal));
return (SCONST);
}
BEGIN(INITIAL);
yylval.str = pstrdup(scanstr(literal));
return (SCONST);
}
<xq>{xqdouble} |
<xq>{xqinside} {
if ((llen+yyleng) > (MAX_PARSE_BUFFER - 1)) {
elog(WARN,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
/* not reached */
}
memcpy(literal+llen, yytext, yyleng+1);
llen += yyleng;
}
<xq>{xqliteral} {
if ((llen+yyleng-1) > (MAX_PARSE_BUFFER - 1)) {
elog(WARN,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
/* not reached */
}
memcpy(literal+llen, yytext+1, yyleng);
llen += yyleng-1;
}
if ((llen+yyleng) > (MAX_PARSE_BUFFER - 1))
elog(WARN,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
memcpy(literal+llen, yytext, yyleng+1);
llen += yyleng;
}
<xq>{xqliteral} {
if ((llen+yyleng-1) > (MAX_PARSE_BUFFER - 1))
elog(WARN,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
memcpy(literal+llen, yytext+1, yyleng);
llen += yyleng-1;
}
{typecast} { return TYPECAST; }
{typecast} { return TYPECAST; }
{selfm} {
yyless(yyleng-2);
return (yytext[0]);
}
{self} { return (yytext[0]); }
{selfm} {
yyless(yyleng-2);
return (yytext[0]);
}
{self} { return (yytext[0]); }
{operatorm} {
yyless(yyleng-2);
yylval.str = pstrdup((char*)yytext);
return (Op);
}
{operator} {
if (strcmp((char*)yytext,"!=") == 0)
yylval.str = pstrdup("<>"); /* compatability */
else
yylval.str = pstrdup((char*)yytext);
return (Op);
}
{param} { yylval.ival = atoi((char*)&yytext[1]);
return (PARAM);
}
{integer} {
yylval.ival = atoi((char*)yytext);
return (ICONST);
}
{real} {
char* endptr;
errno = 0;
yylval.dval = strtod(((char *)yytext),&endptr);
if (*endptr != '\0' || errno == ERANGE)
elog(WARN,"\tBad float8 input format\n");
CheckFloat8Val(yylval.dval);
return (FCONST);
}
{operatorm} {
yyless(yyleng-2);
yylval.str = pstrdup((char*)yytext);
return (Op);
}
{operator} {
if (strcmp((char*)yytext,"!=") == 0)
yylval.str = pstrdup("<>"); /* compatability */
else
yylval.str = pstrdup((char*)yytext);
return (Op);
}
{param} {
yylval.ival = atoi((char*)&yytext[1]);
return (PARAM);
}
{integer} {
yylval.ival = atoi((char*)yytext);
return (ICONST);
}
{real} {
char* endptr;
errno = 0;
yylval.dval = strtod(((char *)yytext),&endptr);
if (*endptr != '\0' || errno == ERANGE)
elog(WARN,"\tBad float8 input format\n");
CheckFloat8Val(yylval.dval);
return (FCONST);
}
{identifier} {
int i;
ScanKeyword *keyword;
int i;
ScanKeyword *keyword;
for(i = strlen(yytext); i >= 0; i--)
if (isupper(yytext[i]))
yytext[i] = tolower(yytext[i]);
keyword = ScanKeywordLookup((char*)yytext);
if (keyword != NULL) {
if ( keyword->value == DEFAULT ) {
DefaultStartPosition = CurScanPosition () + yyleng + 1;
printf( "default offset is %d\n", DefaultStartPosition);
for(i = strlen(yytext); i >= 0; i--)
if (isupper(yytext[i]))
yytext[i] = tolower(yytext[i]);
} else if ( keyword->value == CHECK ) {
CheckStartPosition = CurScanPosition () + yyleng + 1;
printf( "check offset is %d\n", CheckStartPosition);
keyword = ScanKeywordLookup((char*)yytext);
if (keyword != NULL) {
if ( keyword->value == DEFAULT )
{
DefaultStartPosition = CurScanPosition () + yyleng + 1;
printf( "default offset is %d\n", DefaultStartPosition);
}
else if ( keyword->value == CHECK )
{
CheckStartPosition = CurScanPosition () + yyleng + 1;
printf( "check offset is %d\n", CheckStartPosition);
}
return (keyword->value);
}
else
{
yylval.str = pstrdup((char*)yytext);
return (IDENT);
}
}
{space} { /* ignore */ }
};
return (keyword->value);
} else {
yylval.str = pstrdup((char*)yytext);
return (IDENT);
}
}
{space} { /* ignore */ }
{other} { return (yytext[0]); }
{other} { return (yytext[0]); }
%%
void yyerror(char message[])
{
elog(WARN, "parser: %s at or near \"%s\"\n", message, yytext);
elog(WARN, "parser: %s at or near \"%s\"\n", message, yytext);
}
int yywrap()
{
return(1);
return(1);
}
/*
init_io:
called by postgres before any actual parsing is done
called by postgres before any actual parsing is done
*/
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 */
parseCh = NULL;
/* 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)
yy_flush_buffer(YY_CURRENT_BUFFER);
if (YY_CURRENT_BUFFER)
yy_flush_buffer(YY_CURRENT_BUFFER);
#endif /* FLEX_SCANNER */
BEGIN INITIAL;
BEGIN INITIAL;
}
@ -274,63 +274,63 @@ init_io()
int
input()
{
if (parseCh == NULL) {
parseCh = parseString;
return(*parseCh++);
} else if (*parseCh == '\0') {
return(0);
} else {
return(*parseCh++);
}
if (parseCh == NULL)
{
parseCh = parseString;
return(*parseCh++);
}
else if (*parseCh == '\0')
return(0);
else
return(*parseCh++);
}
/* undo lex input from a string instead of from stdin */
void
unput(char c)
{
if (parseCh == NULL) {
elog(FATAL, "Unput() failed.\n");
} else if (c != 0) {
*--parseCh = c;
}
if (parseCh == NULL)
elog(FATAL, "Unput() failed.\n");
else if (c != 0)
*--parseCh = c;
}
int
CurScanPosition(void)
{
return (parseCh - parseString - yyleng);
return (parseCh - parseString - yyleng);
}
#endif /* !defined(FLEX_SCANNER) */
#ifdef FLEX_SCANNER
/* input routine for flex to read input from a string instead of a file */
int
int
myinput(char* buf, int max)
{
int len, copylen;
int len, copylen;
if (parseCh == NULL) {
len = strlen(parseString);
if (len >= max)
copylen = max - 1;
if (parseCh == NULL)
{
len = strlen(parseString);
if (len >= max)
copylen = max - 1;
else
copylen = len;
if (copylen > 0)
memcpy(buf, parseString, copylen);
buf[copylen] = '\0';
parseCh = parseString;
return copylen;
}
else
copylen = len;
if (copylen > 0)
memcpy(buf, parseString, copylen);
buf[copylen] = '\0';
parseCh = parseString;
return copylen;
} else {
return 0; /* end of string */
}
return 0; /* end of string */
}
int
CurScanPosition(void)
{
printf( "current position is %d\n", yy_c_buf_p - yy_current_buffer->yy_ch_buf - yyleng);
return (yy_c_buf_p - yy_current_buffer->yy_ch_buf - yyleng);
printf( "current position is %d\n", yy_c_buf_p - yy_current_buffer->yy_ch_buf - yyleng);
return (yy_c_buf_p - yy_current_buffer->yy_ch_buf - yyleng);
}
#endif /* FLEX_SCANNER */

6
src/lextest/scan.l
View File

@ -1,8 +1,8 @@
%{
/*
This should work, but non-patched flex 2.5.3 fails because input()
doesn't return EOF or '\0'
Bruce Momjian <root@candle.pha.pa.us>
This should work, but non-patched flex 2.5.3 fails because input()
doesn't return EOF or '\0'
Bruce Momjian <root@candle.pha.pa.us>
*/
%}
%%