Sun Mar 10 13:08:22 CET 2002

- Fixed two bugs in define command in lexer.

Thu Mar 21 08:25:08 CET 2002

- Applied patch by Nicolas Bazin <nbazin@ingenico.com.au> for improved

typedef handling.

- Added option '-c' to automatically create C typedef from SQL one.

- Set ecpg version to 2.10.0.

- Set library version to 3.4.0.

{"signed",SQL_SIGNED},

{"static",S_STATIC},

{"struct",SQL_STRUCT},

{"typedef",S_TYPEDEF},

{"union",UNION},

{"unsigned",SQL_UNSIGNED},

{"varchar",VARCHAR},

intret_value=0,

autocommit=0;

autocommit= false;

auto_create_c= false;

struct_include_path*include_paths=NULL;

structcursor*cur=NULL;

structtypedefs*types=NULL;

printf("Usage:\n"

" %s [-d] [-I DIRECTORY] [-o OUTFILE] [-t] file1 [file2...]\n\n",

" %s [-d] [-I DIRECTORY] [-o OUTFILE] [-t][-c] [-D symbol]file1 [file2...]\n\n",

progname);

printf("Usage:\n"

" %s [-I DIRECTORY] [-o OUTFILE] [-t] file1 [file2...]\n\n",

" %s [-I DIRECTORY] [-o OUTFILE] [-t][-c] [-D symbol]file1 [file2...]\n\n",

progname);

printf("Options:\n");

printf(" -I DIRECTORY search DIRECTORY for include files\n");

printf(" -o OUTFILE write result to OUTFILE\n");

printf(" -t turn on autocommit of transactions\n");

printf(" -c automatically generate C code from embedded SQL code\n currently this works for EXEC SQL TYPE\n");

printf(" -D symbol define symbo\n");

printf("\nIf no output file is specified, the name is formed by adding .c\n"

"to the input file name, after stripping off .pgc if present.\n");

printf("\nReport bugs to <pgsql-bugs@postgresql.org>.\n");

include_paths=mm_alloc(sizeof(struct_include_path));

include_paths->path=path;

include_paths->next=ip;

}

add_include_path("/usr/local/include");

add_include_path(".");

while ((c=getopt(argc,argv,"vo:I:tD:d"))!=-1)

while ((c=getopt(argc,argv,"vco:I:tD:d"))!=-1)

{

switch (c)

{

add_include_path(optarg);

break;

case't':

autocommit=1;

autocommit=true;

break;

case'v':

verbose= true;

break;

case'c':

auto_create_c= true;

break;

case'D':

add_preprocessor_define(optarg);

break;

case'd':

externintbraces_open,

autocommit,

auto_create_c,

ret_value,

struct_level;

externchar*descriptor_index;

|AlterUserSetStmt{ output_statement($1,0, connection); }

|ClosePortalStmt{ output_statement($1,0, connection); }

|CommentStmt{ output_statement($1,0, connection); }

|CopyStmt{ output_statement($1,0, connection); }

|CopyStmt{ output_statement($1,0, connection); }

|CreateStmt{ output_statement($1,0, connection); }

|CreateAsStmt{ output_statement($1,0, connection); }

|CreateSchemaStmt{ output_statement($1,0, connection); }

|CreateUserStmt{ output_statement($1,0, connection); }

|ClusterStmt{ output_statement($1,0, connection); }

|DefineStmt{ output_statement($1,0, connection); }

|DropStmt{ output_statement($1,0, connection); }

|DropStmt{ output_statement($1,0, connection); }

|DropSchemaStmt{ output_statement($1,0, connection); }

|TruncateStmt{ output_statement($1,0, connection); }

|DropGroupStmt{ output_statement($1,0, connection); }

|DropPLangStmt{ output_statement($1,0, connection); }

|DropTrigStmt{ output_statement($1,0, connection); }

|DropUserStmt{ output_statement($1,0, connection); }

|ExplainStmt{ output_statement($1,0, connection); }

|FetchStmt{ output_statement($1,1, connection); }

|GrantStmt{ output_statement($1,0, connection); }

|IndexStmt{ output_statement($1,0, connection); }

|FetchStmt{ output_statement($1,1, connection); }

|GrantStmt{ output_statement($1,0, connection); }

|IndexStmt{ output_statement($1,0, connection); }

|ListenStmt{ output_statement($1,0, connection); }

|UnlistenStmt{ output_statement($1,0, connection); }

|LockStmt{ output_statement($1,0, connection); }

|LockStmt{ output_statement($1,0, connection); }

|NotifyStmt{ output_statement($1,0, connection); }

|ProcedureStmt{ output_statement($1,0, connection); }

|ReindexStmt{ output_statement($1,0, connection); }

output_statement($1,1, connection);

}

|RuleStmt{ output_statement($1,0, connection); }

|RuleStmt{ output_statement($1,0, connection); }

{

fprintf(yyout,"{ ECPGtrans(__LINE__, %s,\"%s\");", connection ? connection :"NULL", $1);

whenever_action(2);

free($1);

}

|ViewStmt{ output_statement($1,0, connection); }

|LoadStmt{ output_statement($1,0, connection); }

|ViewStmt{ output_statement($1,0, connection); }

|LoadStmt{ output_statement($1,0, connection); }

|CreatedbStmt{ output_statement($1,0, connection); }

|DropdbStmt{ output_statement($1,0, connection); }

|VacuumStmt{ output_statement($1,0, connection); }

|AnalyzeStmt{ output_statement($1,0, connection); }

|VariableSetStmt{ output_statement($1,0, connection); }

|VariableShowStmt{ output_statement($1,0, connection); }

|VariableResetStmt{ output_statement($1,0, connection); }

|ConstraintsSetStmt{ output_statement($1,0, connection); }

|VariableResetStmt{ output_statement($1,0, connection); }

|ConstraintsSetStmt{ output_statement($1,0, connection); }

|CheckPointStmt{ output_statement($1,0, connection); }

{

if (connection)

mmerror(PARSE_ERROR, ET_ERROR,"no at option for typedef statement.\n");

output_simple_statement($1);

fprintf(yyout,"%s", $1);

free($1);

output_line_number();

}

{

ECPGDeclaration:sql_startdeclare

{ fputs("/* exec sql begin declare section */", yyout); }

{

fprintf(yyout,"%s/* exec sql end declare section */", $3);

free($3);

sql_enddeclare:ecpgstartEND_TRANSDECLARESQL_SECTION';' {};

variable_declarations:/*EMPTY*/{$$ = EMPTY; }

|declarations{$$ =$1; }

var_type_declarations:/*EMPTY*/{$$ = EMPTY; }

|vt_declarations{$$ =$1; }

;

declarations:declaration{$$ =$1; }

|declarationsdeclaration{$$ = cat2_str($1,$2); }

vt_declarations:var_declaration{$$ =$1; }

|type_declaration{$$ =$1; }

|vt_declarationsvar_declaration{$$ = cat2_str($1,$2); }

|vt_declarationstype_declaration{$$ = cat2_str($1,$2); }

;

declaration:storage_clausestorage_modifier

variable_declarations:var_declaration {$$ =$1; }

|variable_declarationsvar_declaration {$$ = cat2_str($1,$2); }

;

type_declaration:S_TYPEDEF

{

initializer =0;

}

{

structtypedefs *ptr, *this;

int dimension =$6.index1;

int length =$6.index2;

if (($3.type_enum == ECPGt_struct ||

$3.type_enum == ECPGt_union) &&

initializer ==1)

{

mmerror(PARSE_ERROR, ET_ERROR,"Initializer not allowed in typedef command");

}

{

for (ptr = types; ptr !=NULL; ptr = ptr->next)

{

if (strcmp($5, ptr->name) ==0)

{

sprintf(errortext,"Type %s already defined", $5);

mmerror(PARSE_ERROR, ET_ERROR, errortext);

}

}

adjust_array($3.type_enum, &dimension, &length, $3.type_dimension, $3.type_index, *$4?1:0);

this = (structtypedefs *) mm_alloc(sizeof(structtypedefs));

this->next = types;

this->name =$5;

this->type = (structthis_type *) mm_alloc(sizeof(structthis_type));

this->type->type_enum =$3.type_enum;

this->type->type_str = mm_strdup($5);

this->type->type_dimension = dimension;/* dimension of array*/

this->type->type_index = length;/* lenght of string*/

this->struct_member_list = ($3.type_enum == ECPGt_struct ||$3.type_enum == ECPGt_union) ?

struct_member_list[struct_level] :NULL;

if ($3.type_enum != ECPGt_varchar &&

$3.type_enum != ECPGt_char &&

$3.type_enum != ECPGt_unsigned_char &&

this->type->type_index >=0)

mmerror(PARSE_ERROR, ET_ERROR,"No multi-dimensional array support for simple data types");

types =this;

}

fprintf(yyout,"typedef %s %s %s %s;\n", $3.type_str, *$4?"*":"", $5, $6.str);

output_line_number();

$$ = make_str("");

};

var_declaration:storage_clausestorage_modifier

{

actual_storage[struct_level] = cat2_str(mm_strdup($1), mm_strdup($2));

actual_startline[struct_level] = hashline_number();

if (($5.type_enum == ECPGt_struct ||

$5.type_enum == ECPGt_union) &&

initializer ==1)

mmerror(PARSE_ERROR, ET_ERROR,"Initializer not allowed in EXEC SQLVAR command");

mmerror(PARSE_ERROR, ET_ERROR,"Initializer not allowed in EXEC SQLTYPE command");

{

for (ptr = types; ptr !=NULL; ptr = ptr->next)

types =this;

}

$$ = cat_str(7, make_str("/* exec sql type"), mm_strdup($3), make_str("is"), mm_strdup($5.type_str), mm_strdup($6.str),$7, make_str("*/"));

if (auto_create_c ==false)

$$ = cat_str(7, make_str("/* exec sql type"), mm_strdup($3), make_str("is"), mm_strdup($5.type_str), mm_strdup($6.str),$7, make_str("*/"));

$$ = cat_str(6, make_str("typedef"), mm_strdup($5.type_str), *$7?make_str("*"):make_str(""), mm_strdup($6.str), mm_strdup($3), make_str(";"));

}

;

;

ECPGTypeName:SQL_BOOL{$$ = make_str("bool"); }

|SQL_INT{$$ = make_str("int"); }

|SQL_LONG{$$ = make_str("long"); }

|SQL_SHORT{$$ = make_str("short"); }

ECPGTypeName:SQL_BOOL{$$ = make_str("bool"); }

|SQL_INT{$$ = make_str("int"); }

|SQL_LONG{$$ = make_str("long"); }

|SQL_SHORT{$$ = make_str("short"); }

|SQL_STRUCT{$$ = make_str("struct"); }

|SQL_SIGNED{$$ = make_str("signed"); }

|SQL_UNSIGNED{$$ = make_str("unsigned"); }

|S_RSHIFT{$$ = make_str(">>"); }

|S_STATIC{$$ = make_str("static"); }

|S_SUB{$$ = make_str("-="); }

|S_TYPEDEF{$$ = make_str("typedef"); }

|SQL_BOOL{$$ = make_str("bool"); }

|SQL_ENUM{$$ = make_str("enum"); }

|SQL_INT{$$ = make_str("int"); }

int

main ()

{

typedef struct { long born; short age; } birthinfo;

exec sql type birthinfo is struct { long born; short age; };

exec sql begin declare section;

typedef struct { long born; short age; } birthinfo;

struct personal_struct{str name;

birthinfo birth;

} personal;