database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-30 11:03:19 +03:00
Code Activity

- Removed space_or_nl and line_end from pgc.l.

Browse Source 
- Fixed several bugs concerning arrays of structs including a memory
  allocation bug.
This commit is contained in:
Michael Meskes
2001-12-23 12:17:41 +00:00
parent aed0c29f7e
commit 988fdce5d1
22 changed files with 393 additions and 268 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/interfaces/ecpg/ChangeLog
View File

@ -1175,5 +1175,14 @@ Sun Dec 9 16:21:30 CET 2001
- Fixed several bugs concerning indicators and added error messages
instead of segfaults.
Thu Dec 20 14:15:56 CET 2001
- Removed space_or_nl and line_end from pgc.l.
Sun Dec 23 13:08:36 CET 2001
- Fixed several bugs concerning arrays of structs including a memory
allocation bug.
- Set ecpg version to 2.9.0.
- Set library version to 3.3.0.

1
src/interfaces/ecpg/include/ecpgerrno.h
View File

@ -25,6 +25,7 @@
#define ECPG_MISSING_INDICATOR -209
#define ECPG_NO_ARRAY -210
#define ECPG_DATA_NOT_ARRAY -211
#define ECPG_ARRAY_INSERT -212
#define ECPG_NO_CONN -220
#define ECPG_NOT_CONN -221

4
src/interfaces/ecpg/lib/Makefile
View File

@ -4,7 +4,7 @@
#
# Copyright (c) 1994, Regents of the University of California
#
# $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/Makefile,v 1.13 2001/09/19 14:09:32 meskes Exp $
# $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/Makefile,v 1.14 2001/12/23 12:17:41 meskes Exp $
#
#-------------------------------------------------------------------------
@ -12,6 +12,8 @@ subdir = src/interfaces/ecpg/lib
top_builddir = ../../../..
include $(top_builddir)/src/Makefile.global
CFLAGS=-g
NAME= ecpg
SO_MAJOR_VERSION= 3
SO_MINOR_VERSION= 3.0

48
src/interfaces/ecpg/lib/connect.c
View File

@ -1,4 +1,4 @@
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/connect.c,v 1.16 2001/12/05 15:32:06 meskes Exp $ */
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/connect.c,v 1.17 2001/12/23 12:17:41 meskes Exp $ */
#include "postgres_fe.h"
@ -52,9 +52,9 @@ ecpg_finish(struct connection * act)
if (actual_connection == act)
actual_connection = all_connections;
for (cache = act->cache_head; cache; ptr = cache, cache = cache->next, free(ptr));
free(act->name);
free(act);
for (cache = act->cache_head; cache; ptr = cache, cache = cache->next, ECPGfree(ptr));
ECPGfree(act->name);
ECPGfree(act);
}
else
ECPGlog("ecpg_finish: called an extra time.\n");
@ -348,15 +348,15 @@ ECPGconnect(int lineno, const char *name, const char *user, const char *passwd,
ECPGlog("connect: socketname %s given for TCP connection in line %d\n", host, lineno);
ECPGraise(lineno, ECPG_CONNECT, realname ? realname : "<DEFAULT>");
if (host)
free(host);
ECPGfree(host);
if (port)
free(port);
ECPGfree(port);
if (options)
free(options);
ECPGfree(options);
if (realname)
free(realname);
ECPGfree(realname);
if (dbname)
free(dbname);
ECPGfree(dbname);
return false;
}
}
@ -371,15 +371,15 @@ ECPGconnect(int lineno, const char *name, const char *user, const char *passwd,
ECPGlog("connect: non-localhost access via sockets in line %d\n", lineno);
ECPGraise(lineno, ECPG_CONNECT, realname ? realname : "<DEFAULT>");
if (host)
free(host);
ECPGfree(host);
if (port)
free(port);
ECPGfree(port);
if (options)
free(options);
ECPGfree(options);
if (realname)
free(realname);
ECPGfree(realname);
if (dbname)
free(dbname);
ECPGfree(dbname);
return false;
}
}
@ -431,28 +431,28 @@ ECPGconnect(int lineno, const char *name, const char *user, const char *passwd,
lineno);
ECPGraise(lineno, ECPG_CONNECT, realname ? realname : "<DEFAULT>");
if (host)
free(host);
ECPGfree(host);
if (port)
free(port);
ECPGfree(port);
if (options)
free(options);
ECPGfree(options);
if (realname)
free(realname);
ECPGfree(realname);
if (dbname)
free(dbname);
ECPGfree(dbname);
return false;
}
if (host)
free(host);
ECPGfree(host);
if (port)
free(port);
ECPGfree(port);
if (options)
free(options);
ECPGfree(options);
if (realname)
free(realname);
ECPGfree(realname);
if (dbname)
free(dbname);
ECPGfree(dbname);
this->committed = true;
this->autocommit = autocommit;

101
src/interfaces/ecpg/lib/data.c
View File

@ -1,4 +1,4 @@
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/data.c,v 1.20 2001/12/05 15:32:06 meskes Exp $ */
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/data.c,v 1.21 2001/12/23 12:17:41 meskes Exp $ */
#include "postgres_fe.h"
@ -15,11 +15,11 @@ bool
ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
enum ECPGttype type, enum ECPGttype ind_type,
void *var, void *ind, long varcharsize, long offset,
bool isarray)
long ind_offset, bool isarray)
{
char *pval = (char *) PQgetvalue(results, act_tuple, act_field);
ECPGlog("ECPGget_data line %d: RESULT: %s\n", lineno, pval ? pval : "");
ECPGlog("ECPGget_data line %d: RESULT: %s offset: %ld\n", lineno, pval ? pval : "", offset);
/* pval is a pointer to the value */
/* let's check is it really is an array if it should be one */
@ -53,23 +53,28 @@ ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
{
case ECPGt_short:
case ECPGt_unsigned_short:
((short *) ind)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);
/* ((short *) ind)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);*/
*((short *) (ind + ind_offset*act_tuple)) = -PQgetisnull(results, act_tuple, act_field);
break;
case ECPGt_int:
case ECPGt_unsigned_int:
((int *) ind)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);
/* ((int *) ind)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);*/
*((int *) (ind + ind_offset*act_tuple)) = -PQgetisnull(results, act_tuple, act_field);
break;
case ECPGt_long:
case ECPGt_unsigned_long:
((long *) ind)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);
/* ((long *) ind)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);*/
*((long *) (ind + ind_offset*act_tuple)) = -PQgetisnull(results, act_tuple, act_field);
break;
#ifdef HAVE_LONG_LONG_INT_64
case ECPGt_long_long:
((long long int *) ind)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);
break;
case ECPGt_unsigned_long_long:
((unsigned long long int *) ind)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);
/* ((long long int *) ind)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);*/
*((long long int *) (ind + ind_offset*act_tuple)) = -PQgetisnull(results, act_tuple, act_field);
break;
/* case ECPGt_unsigned_long_long:
((unsigned long long int *) ind)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);
break;*/
#endif /* HAVE_LONG_LONG_INT_64 */
case ECPGt_NO_INDICATOR:
if (PQgetisnull(results, act_tuple, act_field))
@ -112,13 +117,16 @@ ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
switch (type)
{
case ECPGt_short:
((short *) var)[act_tuple] = (short) res;
/* ((short *) var)[act_tuple] = (short) res;*/
*((short *) (var + offset*act_tuple)) = (short) res;
break;
case ECPGt_int:
((int *) var)[act_tuple] = (int) res;
/* ((int *) var)[act_tuple] = (int) res;*/
*((int *) (var + offset*act_tuple)) = (int) res;
break;
case ECPGt_long:
((long *) var)[act_tuple] = res;
/* ((long *) var)[act_tuple] = res;*/
*((long *) (var + offset*act_tuple)) = (long) res;
break;
default:
/* Cannot happen */
@ -145,13 +153,16 @@ ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
switch (type)
{
case ECPGt_unsigned_short:
((unsigned short *) var)[act_tuple] = (unsigned short) ures;
/* ((unsigned short *) var)[act_tuple] = (unsigned short) ures;*/
*((unsigned short *) (var + offset*act_tuple)) = (unsigned short) res;
break;
case ECPGt_unsigned_int:
((unsigned int *) var)[act_tuple] = (unsigned int) ures;
/* ((unsigned int *) var)[act_tuple] = (unsigned int) ures;*/
*((unsigned int *) (var + offset*act_tuple)) = (unsigned int) res;
break;
case ECPGt_unsigned_long:
((unsigned long *) var)[act_tuple] = ures;
/* ((unsigned long *) var)[act_tuple] = ures;*/
*((unsigned long *) (var + offset*act_tuple)) = (unsigned long) res;
break;
default:
/* Cannot happen */
@ -164,7 +175,8 @@ ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
case ECPGt_long_long:
if (pval)
{
((long long int *) var)[act_tuple] = strtoll(pval, &scan_length, 10);
/* ((long long int *) var)[act_tuple] = strtoll(pval, &scan_length, 10);*/
*((long long int *) (var + offset*act_tuple)) = strtoll(pval, &scan_length, 10);
if ((isarray && *scan_length != ',' && *scan_length != '}')
|| (!isarray && *scan_length != '\0')) /* Garbage left */
{
@ -173,7 +185,8 @@ ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
}
}
else
((long long int *) var)[act_tuple] = (long long) 0;
/* ((long long int *) var)[act_tuple] = (long long) 0;*/
*((long long int *) (var + offset*act_tuple)) = (long long) 0;
break;
#endif /* HAVE_STRTOLL */
@ -181,7 +194,8 @@ ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
case ECPGt_unsigned_long_long:
if (pval)
{
((unsigned long long int *) var)[act_tuple] = strtoull(pval, &scan_length, 10);
/* ((unsigned long long int *) var)[act_tuple] = strtoull(pval, &scan_length, 10);*/
*((unsigned long long int *) (var + offset*act_tuple)) = strtoull(pval, &scan_length, 10);
if ((isarray && *scan_length != ',' && *scan_length != '}')
|| (!isarray && *scan_length != '\0')) /* Garbage left */
{
@ -190,7 +204,8 @@ ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
}
}
else
((unsigned long long int *) var)[act_tuple] = (long long) 0;
/* ((unsigned long long int *) var)[act_tuple] = (long long) 0;*/
*((unsigned long long int *) (var + offset*act_tuple)) = (long long) 0;
break;
#endif /* HAVE_STRTOULL */
@ -221,10 +236,12 @@ ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
switch (type)
{
case ECPGt_float:
((float *) var)[act_tuple] = dres;
/* ((float *) var)[act_tuple] = dres;*/
*((float *) (var + offset*act_tuple)) = dres;
break;
case ECPGt_double:
((double *) var)[act_tuple] = dres;
/* ((double *) var)[act_tuple] = dres;*/
*((double *) (var + offset*act_tuple)) = dres;
break;
default:
/* Cannot happen */
@ -238,9 +255,11 @@ ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
if (pval[0] == 'f' && pval[1] == '\0')
{
if (offset == sizeof(char))
((char *) var)[act_tuple] = false;
/* ((char *) var)[act_tuple] = false;*/
*((char *) (var + offset*act_tuple)) = false;
else if (offset == sizeof(int))
((int *) var)[act_tuple] = false;
/* ((int *) var)[act_tuple] = false;*/
*((int *) (var + offset*act_tuple)) = false;
else
ECPGraise(lineno, ECPG_CONVERT_BOOL, "different size");
break;
@ -248,9 +267,11 @@ ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
else if (pval[0] == 't' && pval[1] == '\0')
{
if (offset == sizeof(char))
((char *) var)[act_tuple] = true;
/* ((char *) var)[act_tuple] = true;*/
*((char *) (var + offset*act_tuple)) = true;
else if (offset == sizeof(int))
((int *) var)[act_tuple] = true;
/* ((int *) var)[act_tuple] = true;*/
*((int *) (var + offset*act_tuple)) = true;
else
ECPGraise(lineno, ECPG_CONVERT_BOOL, "different size");
break;
@ -277,16 +298,25 @@ ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
{
case ECPGt_short:
case ECPGt_unsigned_short:
((short *) ind)[act_tuple] = strlen(pval);
/* ((short *) ind)[act_tuple] = strlen(pval);*/
*((short *) (ind + ind_offset*act_tuple)) = strlen(pval);
break;
case ECPGt_int:
case ECPGt_unsigned_int:
((int *) ind)[act_tuple] = strlen(pval);
/* ((int *) ind)[act_tuple] = strlen(pval);*/
*((int *) (ind + ind_offset*act_tuple)) = strlen(pval);
break;
case ECPGt_long:
case ECPGt_unsigned_long:
((long *) ind)[act_tuple] = strlen(pval);
/* ((long *) ind)[act_tuple] = strlen(pval);*/
*((long *) (ind + ind_offset*act_tuple)) = strlen(pval);
break;
#ifdef HAVE_LONG_LONG_INT_64
case ECPGt_long_long:
case ECPGt_unsigned_long_long:
*((long long int *) (ind + ind_offset*act_tuple)) = strlen(pval);
break;
#endif /* HAVE_LONG_LONG_INT_64 */
default:
break;
}
@ -313,16 +343,25 @@ ECPGget_data(const PGresult *results, int act_tuple, int act_field, int lineno,
{
case ECPGt_short:
case ECPGt_unsigned_short:
((short *) ind)[act_tuple] = variable->len;
/* ((short *) ind)[act_tuple] = variable->len;*/
*((short *) (ind + offset*act_tuple)) = variable->len;
break;
case ECPGt_int:
case ECPGt_unsigned_int:
((int *) ind)[act_tuple] = variable->len;
/* ((int *) ind)[act_tuple] = variable->len;*/
*((int *) (ind + offset*act_tuple)) = variable->len;
break;
case ECPGt_long:
case ECPGt_unsigned_long:
((long *) ind)[act_tuple] = variable->len;
/* ((long *) ind)[act_tuple] = variable->len;*/
*((long *) (ind + offset*act_tuple)) = variable->len;
break;
#ifdef HAVE_LONG_LONG_INT_64
case ECPGt_long_long:
case ECPGt_unsigned_long_long:
*((long long int *) (ind + ind_offset*act_tuple)) = variable->len;
break;
#endif /* HAVE_LONG_LONG_INT_64 */
default:
break;
}

6
src/interfaces/ecpg/lib/descriptor.c
View File

@ -1,6 +1,6 @@
/* dynamic SQL support routines
*
* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/descriptor.c,v 1.19 2001/11/14 11:11:49 meskes Exp $
* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/descriptor.c,v 1.20 2001/12/23 12:17:41 meskes Exp $
*/
#include "postgres_fe.h"
@ -374,9 +374,9 @@ ECPGdeallocate_desc(int line, const char *name)
if (!strcmp(name, i->name))
{
*lastptr = i->next;
free(i->name);
ECPGfree(i->name);
PQclear(i->result);
free(i);
ECPGfree(i);
return true;
}
}

7
src/interfaces/ecpg/lib/error.c
View File

@ -1,4 +1,4 @@
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/error.c,v 1.13 2001/11/14 11:11:49 meskes Exp $ */
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/error.c,v 1.14 2001/12/23 12:17:41 meskes Exp $ */
#include "postgres_fe.h"
@ -82,6 +82,11 @@ ECPGraise(int line, int code, const char *str)
"Data read from backend is not an array in line %d.", line);
break;
case ECPG_ARRAY_INSERT:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Trying to insert an array of variables in line %d.", line);
break;
case ECPG_NO_CONN:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"No such connection %s in line %d.", str, line);

88
src/interfaces/ecpg/lib/execute.c
View File

@ -1,4 +1,4 @@
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/execute.c,v 1.33 2001/11/21 22:57:01 tgl Exp $ */
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/execute.c,v 1.34 2001/12/23 12:17:41 meskes Exp $ */
/*
* The aim is to get a simpler inteface to the database routines.
@ -55,40 +55,6 @@ struct sqlca sqlca =
}
};
/* keep a list of memory we allocated for the user */
static struct auto_mem
{
void *pointer;
struct auto_mem *next;
} *auto_allocs = NULL;
void
ECPGadd_mem(void *ptr, int lineno)
{
struct auto_mem *am = (struct auto_mem *) ECPGalloc(sizeof(struct auto_mem), lineno);
am->pointer = ptr;
am->next = auto_allocs;
auto_allocs = am;
}
void
ECPGfree_auto_mem(void)
{
struct auto_mem *am;
/* free all memory we have allocated for the user */
for (am = auto_allocs; am;)
{
struct auto_mem *act = am;
am = am->next;
free(act->pointer);
free(act);
}
auto_allocs = NULL;
}
/* This function returns a newly malloced string that has the \
in the argument quoted with \ and the ' quote with ' as SQL92 says.
*/
@ -182,7 +148,7 @@ create_statement(int lineno, struct connection * connection, struct statement **
if (var->pointer == NULL)
{
ECPGraise(lineno, ECPG_INVALID_STMT, NULL);
free(var);
ECPGfree(var);
return false;
}
@ -202,7 +168,7 @@ create_statement(int lineno, struct connection * connection, struct statement **
var->ind_offset = va_arg(ap, long);
var->next = NULL;
if (var->ind_type!=ECPGt_NO_INDICATOR
if (var->ind_type != ECPGt_NO_INDICATOR
&& (var->ind_arrsize == 0 || var->ind_varcharsize == 0))
var->ind_value = *((void **) (var->ind_pointer));
else
@ -230,13 +196,13 @@ free_variable(struct variable * var)
if (var == (struct variable *) NULL)
return;
var_next = var->next;
free(var);
ECPGfree(var);
while (var_next)
{
var = var_next;
var_next = var->next;
free(var);
ECPGfree(var);
}
}
@ -247,7 +213,7 @@ free_statement(struct statement * stmt)
return;
free_variable(stmt->inlist);
free_variable(stmt->outlist);
free(stmt);
ECPGfree(stmt);
}
static char *
@ -354,7 +320,7 @@ ECPGis_type_an_array(int type, const struct statement * stmt, const struct varia
array_query = (char *) ECPGalloc(strlen("select typelem from pg_type where oid=") + 11, stmt->lineno);
sprintf(array_query, "select typelem from pg_type where oid=%d", type);
query = PQexec(stmt->connection->connection, array_query);
free(array_query);
ECPGfree(array_query);
if (PQresultStatus(query) == PGRES_TUPLES_OK)
{
isarray = atol((char *) PQgetvalue(query, 0, 0));
@ -460,6 +426,7 @@ ECPGstore_result(const PGresult *results, int act_field,
*((void **) var->pointer) = var->value;
ECPGadd_mem(var->value, stmt->lineno);
}
/* allocate indicator variable if needed */
if ((var->ind_arrsize == 0 || var->ind_varcharsize == 0) && var->ind_value == NULL && var->ind_pointer!=NULL)
{
@ -470,7 +437,6 @@ ECPGstore_result(const PGresult *results, int act_field,
}
/* fill the variable with the tuple(s) */
if (!var->varcharsize && !var->arrsize &&
(var->type==ECPGt_char || var->type==ECPGt_unsigned_char))
{
@ -486,7 +452,7 @@ ECPGstore_result(const PGresult *results, int act_field,
int len = strlen(PQgetvalue(results, act_tuple, act_field)) + 1;
if (!ECPGget_data(results, act_tuple, act_field, stmt->lineno,
var->type, var->ind_type, current_data_location,
var->ind_value, len, 0, isarray))
var->ind_value, len, 0, 0, isarray))
status = false;
else
{
@ -505,7 +471,7 @@ ECPGstore_result(const PGresult *results, int act_field,
{
if (!ECPGget_data(results, act_tuple, act_field, stmt->lineno,
var->type, var->ind_type, var->value,
var->ind_value, var->varcharsize, var->offset, isarray))
var->ind_value, var->varcharsize, var->offset, var->ind_offset, isarray))
status = false;
}
}
@ -519,6 +485,16 @@ ECPGstore_input(const struct statement * stmt, const struct variable * var,
char *mallocedval = NULL;
char *newcopy = NULL;
/*
* arrays are not possible
*/
if (var->arrsize > 1)
{
ECPGraise(stmt->lineno, ECPG_ARRAY_INSERT, NULL);
return false;
}
/*
* Some special treatment is needed for records since we want their
* contents to arrive in a comma-separated list on insert (I think).
@ -816,7 +792,7 @@ ECPGstore_input(const struct statement * stmt, const struct variable * var,
if (!mallocedval)
return false;
free(newcopy);
ECPGfree(newcopy);
*tobeinserted_p = mallocedval;
*malloced_p = true;
@ -851,7 +827,7 @@ ECPGstore_input(const struct statement * stmt, const struct variable * var,
if (!mallocedval)
return false;
free(newcopy);
ECPGfree(newcopy);
*tobeinserted_p = mallocedval;
*malloced_p = true;
@ -936,11 +912,11 @@ ECPGexecute(struct statement * stmt)
*/
if (malloced)
{
free((char *) tobeinserted);
ECPGfree((char *) tobeinserted);
tobeinserted = NULL;
}
free(copiedquery);
ECPGfree(copiedquery);
copiedquery = newcopy;
var = var->next;
@ -968,7 +944,7 @@ ECPGexecute(struct statement * stmt)
ECPGlog("ECPGexecute line %d: QUERY: %s on connection %s\n", stmt->lineno, copiedquery, stmt->connection->name);
results = PQexec(stmt->connection->connection, copiedquery);
free(copiedquery);
ECPGfree(copiedquery);
if (results == NULL)
{
@ -1091,7 +1067,7 @@ ECPGexecute(struct statement * stmt)
{
ECPGlog("ECPGexecute line %d: ASYNC NOTIFY of '%s' from backend pid '%d' received\n",
stmt->lineno, notify->relname, notify->be_pid);
free(notify);
ECPGfree(notify);
}
return status;
@ -1114,15 +1090,16 @@ ECPGdo(int lineno, const char *connection_name, char *query,...)
if (!ECPGinit(con, connection_name, lineno))
{
setlocale(LC_NUMERIC, oldlocale);
free(oldlocale);
ECPGfree(oldlocale);
return (false);
}
/* construct statement in our own structure */
va_start(args, query);
if (create_statement(lineno, con, &stmt, query, args) == false)
{
setlocale(LC_NUMERIC, oldlocale);
free(oldlocale);
ECPGfree(oldlocale);
return (false);
}
va_end(args);
@ -1133,16 +1110,19 @@ ECPGdo(int lineno, const char *connection_name, char *query,...)
free_statement(stmt);
ECPGraise(lineno, ECPG_NOT_CONN, (con) ? con->name : "<empty>");
setlocale(LC_NUMERIC, oldlocale);
free(oldlocale);
ECPGfree(oldlocale);
return false;
}
/* initialize auto_mem struct */
ECPGclear_auto_mem();
status = ECPGexecute(stmt);
free_statement(stmt);
/* and reset locale value so our application is not affected */
setlocale(LC_NUMERIC, oldlocale);
free(oldlocale);
ECPGfree(oldlocale);
return (status);
}

6
src/interfaces/ecpg/lib/extern.h
View File

@ -6,15 +6,17 @@
void ECPGadd_mem(void *ptr, int lineno);
bool ECPGget_data(const PGresult *, int, int, int, enum ECPGttype type,
enum ECPGttype, void *, void *, long, long, bool);
enum ECPGttype, void *, void *, long, long, long, bool);
struct connection *ECPGget_connection(const char *);
void ECPGinit_sqlca(void);
char *ECPGalloc(long, int);
void ECPGfree(void *);
bool ECPGinit(const struct connection *, const char *, const int);
char *ECPGstrdup(const char *, int);
const char *ECPGtype_name(enum ECPGttype);
unsigned int ECPGDynamicType(Oid);
void ECPGfree_auto_mem(void);
void ECPGclear_auto_mem(void);
/* A generic varchar type. */
struct ECPGgeneric_varchar

59
src/interfaces/ecpg/lib/memory.c
View File

@ -1,4 +1,4 @@
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/memory.c,v 1.7 2001/11/14 11:11:49 meskes Exp $ */
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/memory.c,v 1.8 2001/12/23 12:17:41 meskes Exp $ */
#include "postgres_fe.h"
@ -7,6 +7,12 @@
#include "ecpgerrno.h"
#include "extern.h"
void
ECPGfree(void *ptr)
{
free(ptr);
}
char *
ECPGalloc(long size, int lineno)
{
@ -35,3 +41,54 @@ ECPGstrdup(const char *string, int lineno)
return (new);
}
/* keep a list of memory we allocated for the user */
static struct auto_mem
{
void *pointer;
struct auto_mem *next;
} *auto_allocs = NULL;
void
ECPGadd_mem(void *ptr, int lineno)
{
struct auto_mem *am = (struct auto_mem *) ECPGalloc(sizeof(struct auto_mem), lineno);
am->pointer = ptr;
am->next = auto_allocs;
auto_allocs = am;
}
void
ECPGfree_auto_mem(void)
{
struct auto_mem *am;
/* free all memory we have allocated for the user */
for (am = auto_allocs; am;)
{
struct auto_mem *act = am;
am = am->next;
ECPGfree(act->pointer);
ECPGfree(act);
}
auto_allocs = NULL;
}
void
ECPGclear_auto_mem(void)
{
struct auto_mem *am;
/* free just our own structure */
for (am = auto_allocs; am;)
{
struct auto_mem *act = am;
am = am->next;
ECPGfree(act);
}
auto_allocs = NULL;
}

4
src/interfaces/ecpg/lib/misc.c
View File

@ -1,4 +1,4 @@
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/misc.c,v 1.10 2001/11/14 11:11:49 meskes Exp $ */
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/misc.c,v 1.11 2001/12/23 12:17:41 meskes Exp $ */
#include "postgres_fe.h"
@ -137,6 +137,6 @@ ECPGlog(const char *format,...)
vfprintf(debugstream, f, ap);
va_end(ap);
free(f);
ECPGfree(f);
}
}

12
src/interfaces/ecpg/lib/prepare.c
View File

@ -1,4 +1,4 @@
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/prepare.c,v 1.11 2001/11/14 11:11:49 meskes Exp $ */
/* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/prepare.c,v 1.12 2001/12/23 12:17:41 meskes Exp $ */
#include "postgres_fe.h"
@ -76,7 +76,7 @@ ECPGprepare(int lineno, char *name, char *variable)
stmt = (struct statement *) ECPGalloc(sizeof(struct statement), lineno);
if (!stmt)
{
free(this);
ECPGfree(this);
return false;
}
@ -114,15 +114,15 @@ ECPGdeallocate(int lineno, char *name)
if (this)
{
/* okay, free all the resources */
free(this->name);
free(this->stmt->command);
free(this->stmt);
ECPGfree(this->name);
ECPGfree(this->stmt->command);
ECPGfree(this->stmt);
if (prev != NULL)
prev->next = this->next;
else
prep_stmts = this->next;
free(this);
ECPGfree(this);
return true;
}
ECPGraise(lineno, ECPG_INVALID_STMT, name);

4
src/interfaces/ecpg/preproc/Makefile
View File

@ -1,9 +1,11 @@
# $Header: /cvsroot/pgsql/src/interfaces/ecpg/preproc/Makefile,v 1.78 2001/11/16 16:32:33 petere Exp $
# $Header: /cvsroot/pgsql/src/interfaces/ecpg/preproc/Makefile,v 1.79 2001/12/23 12:17:41 meskes Exp $
subdir = src/interfaces/ecpg/preproc
top_builddir = ../../../..
include $(top_builddir)/src/Makefile.global
CFLAGS+=-g
MAJOR_VERSION=2
MINOR_VERSION=9
PATCHLEVEL=0

4
src/interfaces/ecpg/preproc/descriptor.c
View File

@ -45,7 +45,7 @@ ECPGnumeric_lvalue(FILE *f, char *name)
{
const struct variable *v = find_variable(name);
switch (v->type->typ)
switch (v->type->type)
{
case ECPGt_short:
case ECPGt_int:
@ -192,7 +192,7 @@ output_get_descr(char *desc_name, char *index)
break;
}
fprintf(yyout, "%s,", get_dtype(results->value));
ECPGdump_a_type(yyout, v->name, v->type, NULL, NULL, NULL, NULL);
ECPGdump_a_type(yyout, v->name, v->type, NULL, NULL, NULL, NULL, 0L, NULL, NULL);
}
drop_assignments();
fputs("ECPGd_EODT);\n", yyout);

30
src/interfaces/ecpg/preproc/pgc.l
View File

@ -12,7 +12,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/interfaces/ecpg/preproc/pgc.l,v 1.82 2001/12/09 15:27:49 meskes Exp $
* $Header: /cvsroot/pgsql/src/interfaces/ecpg/preproc/pgc.l,v 1.83 2001/12/23 12:17:41 meskes Exp $
*
*-------------------------------------------------------------------------
*/
@ -219,9 +219,7 @@ param \${integer}
ccomment "//".*\n
space [ \t\r\f]
space_or_nl [ \t\r\f\n]
line_end {space}*\n
space [ \t\n\r\f]
horiz_space [ \t\f]
newline [\n\r]
non_newline [^\n\r]
@ -254,12 +252,12 @@ else [eE][lL][sS][eE]
elif [eE][lL][iI][fF]
endif [eE][nN][dD][iI][fF]
exec_sql {exec}{space_or_nl}*{sql}{space_or_nl}*
exec_sql {exec}{space}*{sql}{space}*
ipdigit ({digit}|{digit}{digit}|{digit}{digit}{digit})
ip {ipdigit}\.{ipdigit}\.{ipdigit}\.{ipdigit}
/* Take care of cpp continuation lines */
cppline {space}*#(.*\\{line_end})*.*
cppline {space}*#(.*\\{space})*.*
/* DO NOT PUT ANY COMMENTS IN THE FOLLOWING SECTION.
* AT&T lex does not properly handle C-style comments in this second lex block.
@ -655,7 +653,7 @@ cppline {space}*#(.*\\{line_end})*.*
<C>"-" { return('-'); }
<C>"(" { return('('); }
<C>")" { return(')'); }
<C>{space_or_nl} { ECHO; }
<C>{space} { ECHO; }
<C>\{ { return('{'); }
<C>\} { return('}'); }
<C>\[ { return('['); }
@ -679,13 +677,13 @@ cppline {space}*#(.*\\{line_end})*.*
<C>".*" { return(S_DOTPOINT); }
<C>{other} { return S_ANYTHING; }
<C>{exec_sql}{define}{space_or_nl}* { BEGIN(def_ident); }
<C>{exec_sql}{include}{space_or_nl}* { BEGIN(incl); }
<C>{exec_sql}{define}{space}* { BEGIN(def_ident); }
<C>{exec_sql}{include}{space}* { BEGIN(incl); }
<C,xskip>{exec_sql}{ifdef}{space_or_nl}* { ifcond = TRUE; BEGIN(xcond); }
<C,xskip>{exec_sql}{ifndef}{space_or_nl}* { ifcond = FALSE; BEGIN(xcond); }
<C,xskip>{exec_sql}{ifdef}{space}* { ifcond = TRUE; BEGIN(xcond); }
<C,xskip>{exec_sql}{ifndef}{space}* { ifcond = FALSE; BEGIN(xcond); }
<C,xskip>{exec_sql}{elif}{space_or_nl}* { /* pop stack */
<C,xskip>{exec_sql}{elif}{space}* { /* pop stack */
if ( preproc_tos == 0 ) {
mmerror(PARSE_ERROR, ET_FATAL, "Missing matching 'EXEC SQL IFDEF / EXEC SQL IFNDEF'");
}
@ -699,7 +697,7 @@ cppline {space}*#(.*\\{line_end})*.*
ifcond = TRUE; BEGIN(xcond);
}
<C,xskip>{exec_sql}{else}{space_or_nl}*";" { /* only exec sql endif pops the stack, so take care of duplicated 'else' */
<C,xskip>{exec_sql}{else}{space}*";" { /* only exec sql endif pops the stack, so take care of duplicated 'else' */
if ( stacked_if_value[preproc_tos].else_branch ) {
mmerror(PARSE_ERROR, ET_FATAL, "Duplicated 'EXEC SQL ELSE;'");
}
@ -717,7 +715,7 @@ cppline {space}*#(.*\\{line_end})*.*
}
}
}
<C,xskip>{exec_sql}{endif}{space_or_nl}*";" {
<C,xskip>{exec_sql}{endif}{space}*";" {
if ( preproc_tos == 0 ) {
mmerror(PARSE_ERROR, ET_FATAL, "Unmatched 'EXEC SQL ENDIF;'");
}
@ -735,7 +733,7 @@ cppline {space}*#(.*\\{line_end})*.*
<xskip>{other} { /* ignore */ }
<xcond>{identifier}{space_or_nl}*";" {
<xcond>{identifier}{space}*";" {
if ( preproc_tos >= MAX_NESTED_IF-1 ) {
mmerror(PARSE_ERROR, ET_FATAL, "Too many nested 'EXEC SQL IFDEF' conditions");
}
@ -773,7 +771,7 @@ cppline {space}*#(.*\\{line_end})*.*
BEGIN(def);
startlit();
}
<def>{space_or_nl}*";" {
<def>{space}*";" {
struct _defines *ptr, *this;
for (ptr = defines; ptr != NULL; ptr = ptr->next)

45
src/interfaces/ecpg/preproc/preproc.y
View File

@ -22,10 +22,13 @@ static char *actual_startline[STRUCT_DEPTH];
/* temporarily store struct members while creating the data structure */
struct ECPGstruct_member *struct_member_list[STRUCT_DEPTH] = { NULL };
struct ECPGtype ecpg_no_indicator = {ECPGt_NO_INDICATOR, 0L, {NULL}};
/* also store struct type so we can do a sizeof() later */
static char *ECPGstruct_sizeof = NULL;
struct ECPGtype ecpg_no_indicator = {ECPGt_NO_INDICATOR, 0L, NULL, {NULL}};
struct variable no_indicator = {"no_indicator", &ecpg_no_indicator, 0, NULL};
struct ECPGtype ecpg_query = {ECPGt_char_variable, 0L, {NULL}};
struct ECPGtype ecpg_query = {ECPGt_char_variable, 0L, NULL, {NULL}};
/*
* Handle parsing errors and warnings
@ -3914,14 +3917,14 @@ connection_target: database_name opt_server opt_port
$$ = $1;
else if (strcmp($1, "?") == 0) /* variable */
{
enum ECPGttype typ = argsinsert->variable->type->typ;
enum ECPGttype type = argsinsert->variable->type->type;
/* if array see what's inside */
if (typ == ECPGt_array)
typ = argsinsert->variable->type->u.element->typ;
if (type == ECPGt_array)
type = argsinsert->variable->type->u.element->type;
/* handle varchars */
if (typ == ECPGt_varchar)
if (type == ECPGt_varchar)
$$ = make2_str(mm_strdup(argsinsert->variable->name), make_str(".arr"));
else
$$ = mm_strdup(argsinsert->variable->name);
@ -4002,14 +4005,14 @@ user_name: UserId {
$$ = $1;
else if (strcmp($1, "?") == 0) /* variable */
{
enum ECPGttype typ = argsinsert->variable->type->typ;
enum ECPGttype type = argsinsert->variable->type->type;
/* if array see what's inside */
if (typ == ECPGt_array)
typ = argsinsert->variable->type->u.element->typ;
if (type == ECPGt_array)
type = argsinsert->variable->type->u.element->type;
/* handle varchars */
if (typ == ECPGt_varchar)
if (type == ECPGt_varchar)
$$ = make2_str(mm_strdup(argsinsert->variable->name), make_str(".arr"));
else
$$ = mm_strdup(argsinsert->variable->name);
@ -4021,13 +4024,13 @@ user_name: UserId {
char_variable: cvariable
{ /* check if we have a char variable */
struct variable *p = find_variable($1);
enum ECPGttype typ = p->type->typ;
enum ECPGttype type = p->type->type;
/* if array see what's inside */
if (typ == ECPGt_array)
typ = p->type->u.element->typ;
if (type == ECPGt_array)
type = p->type->u.element->type;
switch (typ)
switch (type)
{
case ECPGt_char:
case ECPGt_unsigned_char:
@ -4267,10 +4270,10 @@ union_type: s_union '{' variable_declarations '}'
s_struct: SQL_STRUCT opt_symbol
{
struct_member_list[struct_level++] = NULL;
$$ = cat2_str(make_str("struct"), $2);
ECPGstruct_sizeof = cat_str(3, make_str("sizeof("), strdup($$), make_str(")"));
if (struct_level >= STRUCT_DEPTH)
mmerror(PARSE_ERROR, ET_ERROR, "Too many levels in nested structure definition");
$$ = cat2_str(make_str("struct"), $2);
};
s_union: UNION opt_symbol
@ -4360,9 +4363,9 @@ variable: opt_pointer ECPGColLabel opt_array_bounds opt_initializer
case ECPGt_struct:
case ECPGt_union:
if (dimension < 0)
type = ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum);
type = ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum, ECPGstruct_sizeof);
else
type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum), dimension);
type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum, ECPGstruct_sizeof), dimension);
$$ = cat_str(4, $1, mm_strdup($2), $3.str, $4);
break;
@ -4783,9 +4786,9 @@ ECPGVar: SQL_VAR
case ECPGt_struct:
case ECPGt_union:
if (dimension < 0)
type = ECPGmake_struct_type(struct_member_list[struct_level], $5.type_enum);
type = ECPGmake_struct_type(struct_member_list[struct_level], $5.type_enum, ECPGstruct_sizeof);
else
type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], $5.type_enum), dimension);
type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], $5.type_enum, ECPGstruct_sizeof), dimension);
break;
case ECPGt_varchar:
if (dimension == -1)
@ -5337,7 +5340,7 @@ coutputvariable: cvariable indicator
civarind: cvariable indicator
{
if ($2 != NULL && (find_variable($2))->type->typ == ECPGt_array)
if ($2 != NULL && (find_variable($2))->type->type == ECPGt_array)
mmerror(PARSE_ERROR, ET_ERROR, "arrays of indicators are not allowed on input");
add_variable(&argsinsert, find_variable($1), ($2 == NULL) ? &no_indicator : find_variable($2));

156
src/interfaces/ecpg/preproc/type.c
View File

@ -2,7 +2,7 @@
#include "extern.h"
#define indicator_set ind_typ != NULL && ind_typ->typ != ECPGt_NO_INDICATOR
#define indicator_set ind_type != NULL && ind_type->type != ECPGt_NO_INDICATOR
struct ECPGstruct_member struct_no_indicator = {"no_indicator", &ecpg_no_indicator, NULL};
@ -40,17 +40,17 @@ ECPGstruct_member_dup(struct ECPGstruct_member * rm)
{
struct ECPGtype *type;
switch (rm->typ->typ)
switch (rm->type->type)
{
case ECPGt_struct:
case ECPGt_union:
type = ECPGmake_struct_type(rm->typ->u.members, rm->typ->typ);
type = ECPGmake_struct_type(rm->type->u.members, rm->type->type, rm->type->struct_sizeof);
break;
case ECPGt_array:
type = ECPGmake_array_type(ECPGmake_simple_type(rm->typ->u.element->typ, rm->typ->u.element->size), rm->typ->size);
type = ECPGmake_array_type(ECPGmake_simple_type(rm->type->u.element->type, rm->type->u.element->size), rm->type->size);
break;
default:
type = ECPGmake_simple_type(rm->typ->typ, rm->typ->size);
type = ECPGmake_simple_type(rm->type->type, rm->type->size);
break;
}
@ -71,7 +71,7 @@ ECPGmake_struct_member(char *name, struct ECPGtype * type, struct ECPGstruct_mem
(struct ECPGstruct_member *) mm_alloc(sizeof(struct ECPGstruct_member));
ne->name = strdup(name);
ne->typ = type;
ne->type = type;
ne->next = NULL;
for (ptr = *start; ptr && ptr->next; ptr = ptr->next);
@ -83,41 +83,43 @@ ECPGmake_struct_member(char *name, struct ECPGtype * type, struct ECPGstruct_mem
}
struct ECPGtype *
ECPGmake_simple_type(enum ECPGttype typ, long siz)
ECPGmake_simple_type(enum ECPGttype type, long size)
{
struct ECPGtype *ne = (struct ECPGtype *) mm_alloc(sizeof(struct ECPGtype));
ne->typ = typ;
ne->size = siz;
ne->type = type;
ne->size = size;
ne->u.element = 0;
ne->struct_sizeof = NULL;
return ne;
}
struct ECPGtype *
ECPGmake_array_type(struct ECPGtype * typ, long siz)
ECPGmake_array_type(struct ECPGtype * type, long size)
{
struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_array, siz);
struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_array, size);
ne->u.element = typ;
ne->u.element = type;
return ne;
}
struct ECPGtype *
ECPGmake_struct_type(struct ECPGstruct_member * rm, enum ECPGttype type)
ECPGmake_struct_type(struct ECPGstruct_member * rm, enum ECPGttype type, char *struct_sizeof)
{
struct ECPGtype *ne = ECPGmake_simple_type(type, 1);
ne->u.members = ECPGstruct_member_dup(rm);
ne->struct_sizeof = struct_sizeof;
return ne;
}
static const char *
get_type(enum ECPGttype typ)
get_type(enum ECPGttype type)
{
switch (typ)
switch (type)
{
case ECPGt_char:
return ("ECPGt_char");
@ -171,7 +173,7 @@ get_type(enum ECPGttype typ)
return ("ECPGt_descriptor");
break;
default:
sprintf(errortext, "illegal variable type %d\n", typ);
sprintf(errortext, "illegal variable type %d\n", type);
yyerror(errortext);
}
@ -192,76 +194,76 @@ get_type(enum ECPGttype typ)
size is the maxsize in case it is a varchar. Otherwise it is the size of
the variable (required to do array fetches of structs).
*/
static void ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
static void ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype type,
long varcharsize,
long arrsiz, const char *siz, const char *prefix);
static void ECPGdump_a_struct(FILE *o, const char *name, const char *ind_name, long arrsiz,
struct ECPGtype * typ, struct ECPGtype * ind_typ, const char *offset, const char *prefix, const char *ind_prefix);
struct ECPGtype * type, struct ECPGtype * ind_type, const char *offset, const char *prefix, const char *ind_prefix);
void
ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype * typ, const char *ind_name, struct ECPGtype * ind_typ, const char *prefix, const char *ind_prefix)
ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype * type, const char *ind_name, struct ECPGtype * ind_type, const char *prefix, const char *ind_prefix, const long arr_str_siz, const char *struct_sizeof, const char *ind_struct_sizeof)
{
switch (typ->typ)
switch (type->type)
{
case ECPGt_array:
if (indicator_set && ind_typ->typ != ECPGt_array)
if (indicator_set && ind_type->type != ECPGt_array)
mmerror(INDICATOR_NOT_ARRAY, ET_FATAL, "Indicator for array/pointer has to be array/pointer.\n");
switch (typ->u.element->typ)
switch (type->u.element->type)
{
case ECPGt_array:
mmerror(PARSE_ERROR, ET_ERROR, "No nested arrays allowed (except strings)"); /* array of array */
break;
case ECPGt_struct:
case ECPGt_union:
ECPGdump_a_struct(o, name, ind_name, typ->size, typ->u.element, ind_typ->u.element, NULL, prefix, ind_prefix);
ECPGdump_a_struct(o, name, ind_name, type->size, type->u.element, (ind_type->type == ECPGt_NO_INDICATOR) ? ind_type : ind_type->u.element, NULL, prefix, ind_prefix);
break;
default:
if (!IS_SIMPLE_TYPE(typ->u.element->typ))
if (!IS_SIMPLE_TYPE(type->u.element->type))
yyerror("Internal error: unknown datatype, please inform pgsql-bugs@postgresql.org");
ECPGdump_a_simple(o, name, typ->u.element->typ,
typ->u.element->size, typ->size, NULL, prefix);
if (ind_typ != NULL)
ECPGdump_a_simple(o, name, type->u.element->type,
type->u.element->size, type->size, NULL, prefix);
if (ind_type != NULL)
{
if (ind_typ->typ == ECPGt_NO_INDICATOR)
ECPGdump_a_simple(o, ind_name, ind_typ->typ, ind_typ->size, -1, NULL, ind_prefix);
if (ind_type->type == ECPGt_NO_INDICATOR)
ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, -1, NULL, ind_prefix);
else
ECPGdump_a_simple(o, ind_name, ind_typ->u.element->typ,
ind_typ->u.element->size, ind_typ->size, NULL, prefix);
ECPGdump_a_simple(o, ind_name, ind_type->u.element->type,
ind_type->u.element->size, ind_type->size, NULL, prefix);
}
}
break;
case ECPGt_struct:
if (indicator_set && ind_typ->typ != ECPGt_struct)
if (indicator_set && ind_type->type != ECPGt_struct)
mmerror(INDICATOR_NOT_STRUCT, ET_FATAL, "Indicator for struct has to be struct.\n");
ECPGdump_a_struct(o, name, ind_name, 1, typ, ind_typ, NULL, prefix, ind_prefix);
ECPGdump_a_struct(o, name, ind_name, 1, type, ind_type, NULL, prefix, ind_prefix);
break;
case ECPGt_union: /* cannot dump a complete union */
yyerror("Type of union has to be specified");
break;
case ECPGt_char_variable:
if (indicator_set && (ind_typ->typ == ECPGt_struct || ind_typ->typ == ECPGt_array))
if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
mmerror(INDICATOR_NOT_SIMPLE, ET_FATAL, "Indicator for simple datatype has to be simple.\n");
ECPGdump_a_simple(o, name, typ->typ, 1, 1, NULL, prefix);
ECPGdump_a_simple(o, ind_name, ind_typ->typ, ind_typ->size, -1, NULL, ind_prefix);
ECPGdump_a_simple(o, name, type->type, 1, arr_str_siz ? arr_str_siz : 1, struct_sizeof, prefix);
ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, arr_str_siz ? arr_str_siz : -1, ind_struct_sizeof, ind_prefix);
break;
case ECPGt_descriptor:
if (indicator_set && (ind_typ->typ == ECPGt_struct || ind_typ->typ == ECPGt_array))
if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
mmerror(INDICATOR_NOT_SIMPLE, ET_FATAL, "Indicator for simple datatype has to be simple.\n");
ECPGdump_a_simple(o, name, typ->typ, 0, -1, NULL, prefix);
ECPGdump_a_simple(o, ind_name, ind_typ->typ, ind_typ->size, -1, NULL, ind_prefix);
ECPGdump_a_simple(o, name, type->type, 0, -1, NULL, prefix);
ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, -1, NULL, ind_prefix);
break;
default:
if (indicator_set && (ind_typ->typ == ECPGt_struct || ind_typ->typ == ECPGt_array))
if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
mmerror(INDICATOR_NOT_SIMPLE, ET_FATAL, "Indicator for simple datatype has to be simple.\n");
ECPGdump_a_simple(o, name, typ->typ, typ->size, -1, NULL, prefix);
if (ind_typ != NULL)
ECPGdump_a_simple(o, ind_name, ind_typ->typ, ind_typ->size, -1, NULL, ind_prefix);
ECPGdump_a_simple(o, name, type->type, type->size, arr_str_siz ? arr_str_siz : -1, struct_sizeof, prefix);
if (ind_type != NULL)
ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, arr_str_siz ? arr_str_siz : -1, ind_struct_sizeof, ind_prefix);
break;
}
}
@ -270,16 +272,16 @@ ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype * typ, const char *in
/* If siz is NULL, then the offset is 0, if not use siz as a
string, it represents the offset needed if we are in an array of structs. */
static void
ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype type,
long varcharsize,
long arrsize,
const char *siz,
const char *prefix
)
{
if (typ == ECPGt_NO_INDICATOR)
if (type == ECPGt_NO_INDICATOR)
fprintf(o, "\n\tECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ");
else if (typ == ECPGt_descriptor)
else if (type == ECPGt_descriptor)
/* remember that name here already contains quotes (if needed) */
fprintf(o, "\n\tECPGt_descriptor, %s, 0L, 0L, 0L, ", name);
else
@ -287,7 +289,7 @@ ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
char *variable = (char *) mm_alloc(strlen(name) + ((prefix == NULL) ? 0 : strlen(prefix)) + 4);
char *offset = (char *) mm_alloc(strlen(name) + strlen("sizeof(struct varchar_)") + 1);
switch (typ)
switch (type)
{
case ECPGt_varchar:
@ -295,7 +297,7 @@ ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
* we have to use the pointer except for arrays with given
* bounds
*/
if (arrsize > 0)
if (arrsize > 0 && siz == NULL)
sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
else
sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
@ -310,7 +312,7 @@ ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
* we have to use the pointer except for arrays with given
* bounds
*/
if (varcharsize > 1 || arrsize > 0)
if ((varcharsize > 1 || arrsize > 0) && siz == NULL)
sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
else
sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
@ -323,22 +325,22 @@ ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
* we have to use the pointer except for arrays with given
* bounds
*/
if (arrsize > 0)
if (arrsize > 0 && siz== NULL)
sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
else
sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
sprintf(offset, "sizeof(%s)", ECPGtype_name(typ));
sprintf(offset, "sizeof(%s)", ECPGtype_name(type));
break;
}
if (arrsize < 0)
arrsize = 1;
if (siz == NULL)
fprintf(o, "\n\t%s,%s,%ldL,%ldL,%s, ", get_type(typ), variable, varcharsize, arrsize, offset);
if (siz == NULL || arrsize <= 1)
fprintf(o, "\n\t%s,%s,%ldL,%ldL,%s, ", get_type(type), variable, varcharsize, arrsize, offset);
else
fprintf(o, "\n\t%s,%s,%ldL,%ldL,%s, ", get_type(typ), variable, varcharsize, arrsize, siz);
fprintf(o, "\n\t%s,%s,%ldL,%ldL,%s, ", get_type(type), variable, varcharsize, arrsize, siz);
free(variable);
free(offset);
@ -348,7 +350,7 @@ ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
/* Penetrate a struct and dump the contents. */
static void
ECPGdump_a_struct(FILE *o, const char *name, const char *ind_name, long arrsiz, struct ECPGtype * typ, struct ECPGtype * ind_typ, const char *offsetarg, const char *prefix, const char *ind_prefix)
ECPGdump_a_struct(FILE *o, const char *name, const char *ind_name, long arrsiz, struct ECPGtype * type, struct ECPGtype * ind_type, const char *offsetarg, const char *prefix, const char *ind_prefix)
{
/*
* If offset is NULL, then this is the first recursive level. If not
@ -370,31 +372,31 @@ ECPGdump_a_struct(FILE *o, const char *name, const char *ind_name, long arrsiz,
else
offset = offsetarg;
if (arrsiz != 0)
if (arrsiz == 1)
sprintf(pbuf, "%s%s.", prefix ? prefix : "", name);
else
sprintf(pbuf, "%s%s->", prefix ? prefix : "", name);
prefix = pbuf;
if (ind_typ == &ecpg_no_indicator)
if (ind_type == &ecpg_no_indicator)
{
ind_p = &struct_no_indicator;
}
else if (ind_typ != NULL)
else if (ind_type != NULL)
{
if (arrsiz != 0)
if (arrsiz == 1)
sprintf(ind_pbuf, "%s%s.", ind_prefix ? ind_prefix : "", ind_name);
else
sprintf(ind_pbuf, "%s%s->", ind_prefix ? ind_prefix : "", ind_name);
ind_prefix = ind_pbuf;
ind_p = ind_typ->u.members;
ind_p = ind_type->u.members;
}
for (p = typ->u.members; p; p = p->next)
for (p = type->u.members; p; p = p->next)
{
ECPGdump_a_type(o, p->name, p->typ, (ind_p != NULL) ? ind_p->name : NULL, (ind_p != NULL) ? ind_p->typ : NULL, prefix, ind_prefix);
ECPGdump_a_type(o, p->name, p->type, (ind_p != NULL) ? ind_p->name : NULL, (ind_p != NULL) ? ind_p->type : NULL, prefix, ind_prefix, arrsiz, type->struct_sizeof, (ind_p != NULL) ? ind_type->struct_sizeof : NULL);
if (ind_p != NULL && ind_p != &struct_no_indicator)
ind_p = ind_p->next;
}
@ -409,20 +411,20 @@ ECPGfree_struct_member(struct ECPGstruct_member * rm)
rm = rm->next;
free(p->name);
free(p->typ);
free(p->type);
free(p);
}
}
void
ECPGfree_type(struct ECPGtype * typ)
ECPGfree_type(struct ECPGtype * type)
{
if (!IS_SIMPLE_TYPE(typ->typ))
if (!IS_SIMPLE_TYPE(type->type))
{
switch (typ->typ)
switch (type->type)
{
case ECPGt_array:
switch (typ->u.element->typ)
switch (type->u.element->type)
{
case ECPGt_array:
yyerror("internal error, found multi-dimensional array\n");
@ -430,33 +432,33 @@ ECPGfree_type(struct ECPGtype * typ)
case ECPGt_struct:
case ECPGt_union:
/* Array of structs. */
ECPGfree_struct_member(typ->u.element->u.members);
free(typ->u.element);
ECPGfree_struct_member(type->u.element->u.members);
free(type->u.element);
break;
default:
if (!IS_SIMPLE_TYPE(typ->u.element->typ))
if (!IS_SIMPLE_TYPE(type->u.element->type))
yyerror("Internal error: unknown datatype, please inform pgsql-bugs@postgresql.org");
free(typ->u.element);
free(type->u.element);
}
break;
case ECPGt_struct:
case ECPGt_union:
ECPGfree_struct_member(typ->u.members);
ECPGfree_struct_member(type->u.members);
break;
default:
sprintf(errortext, "illegal variable type %d\n", typ->typ);
sprintf(errortext, "illegal variable type %d\n", type->type);
yyerror(errortext);
break;
}
}
free(typ);
free(type);
}
const char *
get_dtype(enum ECPGdtype typ)
get_dtype(enum ECPGdtype type)
{
switch (typ)
switch (type)
{
case ECPGd_count:
return ("ECPGd_countr");
@ -505,7 +507,7 @@ get_dtype(enum ECPGdtype typ)
case ECPGd_cardinality:
return ("ECPGd_cardinality");
default:
sprintf(errortext, "illegal descriptor item %d\n", typ);
sprintf(errortext, "illegal descriptor item %d\n", type);
yyerror(errortext);
}

13
src/interfaces/ecpg/preproc/type.h
View File

@ -4,16 +4,17 @@ struct ECPGtype;
struct ECPGstruct_member
{
char *name;
struct ECPGtype *typ;
struct ECPGtype *type;
struct ECPGstruct_member *next;
};
struct ECPGtype
{
enum ECPGttype typ;
enum ECPGttype type;
long size; /* For array it is the number of elements.
* For varchar it is the maxsize of the
* area. */
char *struct_sizeof; /* For a struct this is the sizeof() type as string */
union
{
struct ECPGtype *element; /* For an array this is the type
@ -29,7 +30,7 @@ void ECPGmake_struct_member(char *, struct ECPGtype *, struct ECPGstruct_member
struct ECPGtype *ECPGmake_simple_type(enum ECPGttype, long);
struct ECPGtype *ECPGmake_varchar_type(enum ECPGttype, long);
struct ECPGtype *ECPGmake_array_type(struct ECPGtype *, long);
struct ECPGtype *ECPGmake_struct_type(struct ECPGstruct_member *, enum ECPGttype type);
struct ECPGtype *ECPGmake_struct_type(struct ECPGstruct_member *, enum ECPGttype, char *);
struct ECPGstruct_member *ECPGstruct_member_dup(struct ECPGstruct_member *);
/* Frees a type. */
@ -46,16 +47,16 @@ void ECPGfree_type(struct ECPGtype *);
size is the maxsize in case it is a varchar. Otherwise it is the size of
the variable (required to do array fetches of structs).
*/
void ECPGdump_a_type(FILE *, const char *, struct ECPGtype *, const char *, struct ECPGtype *, const char *, const char *);
void ECPGdump_a_type(FILE *, const char *, struct ECPGtype *, const char *, struct ECPGtype *, const char *, const char *, const long, const char *, const char *);
/* A simple struct to keep a variable and its type. */
struct ECPGtemp_type
{
struct ECPGtype *typ;
struct ECPGtype *type;
const char *name;
};
extern const char *ECPGtype_name(enum ECPGttype typ);
extern const char *ECPGtype_name(enum ECPGttype type);
/* some stuff for whenever statements */
enum WHEN_TYPE

24
src/interfaces/ecpg/preproc/variable.c
View File

@ -38,15 +38,15 @@ find_struct_member(char *name, char *str, struct ECPGstruct_member * members)
if (c == '\0')
{
/* found the end */
switch (members->typ->typ)
switch (members->type->type)
{
case ECPGt_array:
return (new_variable(name, ECPGmake_array_type(members->typ->u.element, members->typ->size)));
return (new_variable(name, ECPGmake_array_type(members->type->u.element, members->type->size)));
case ECPGt_struct:
case ECPGt_union:
return (new_variable(name, ECPGmake_struct_type(members->typ->u.members, members->typ->typ)));
return (new_variable(name, ECPGmake_struct_type(members->type->u.members, members->type->type, members->type->struct_sizeof)));
default:
return (new_variable(name, ECPGmake_simple_type(members->typ->typ, members->typ->size)));
return (new_variable(name, ECPGmake_simple_type(members->type->type, members->type->size)));
}
}
else
@ -55,10 +55,10 @@ find_struct_member(char *name, char *str, struct ECPGstruct_member * members)
if (c == '-')
{
next++;
return (find_struct_member(name, next, members->typ->u.element->u.members));
return (find_struct_member(name, next, members->type->u.element->u.members));
}
else
return (find_struct_member(name, next, members->typ->u.members));
return (find_struct_member(name, next, members->type->u.members));
}
}
}
@ -78,13 +78,13 @@ find_struct(char *name, char *next)
if (c == '-')
{
if (p->type->typ != ECPGt_array)
if (p->type->type != ECPGt_array)
{
sprintf(errortext, "variable %s is not a pointer", name);
mmerror(PARSE_ERROR, ET_FATAL, errortext);
}
if (p->type->u.element->typ != ECPGt_struct && p->type->u.element->typ != ECPGt_union)
if (p->type->u.element->type != ECPGt_struct && p->type->u.element->type != ECPGt_union)
{
sprintf(errortext, "variable %s is not a pointer to a structure or a union", name);
mmerror(PARSE_ERROR, ET_FATAL, errortext);
@ -98,7 +98,7 @@ find_struct(char *name, char *next)
}
else
{
if (p->type->typ != ECPGt_struct && p->type->typ != ECPGt_union)
if (p->type->type != ECPGt_struct && p->type->type != ECPGt_union)
{
sprintf(errortext, "variable %s is neither a structure nor a union", name);
mmerror(PARSE_ERROR, ET_FATAL, errortext);
@ -242,7 +242,7 @@ dump_variables(struct arguments * list, int mode)
/* Then the current element and its indicator */
ECPGdump_a_type(yyout, list->variable->name, list->variable->type,
list->indicator->name, list->indicator->type, NULL, NULL);
list->indicator->name, list->indicator->type, NULL, NULL, 0, NULL, NULL);
/* Then release the list element. */
if (mode != 0)
@ -253,7 +253,7 @@ void
check_indicator(struct ECPGtype * var)
{
/* make sure this is a valid indicator variable */
switch (var->typ)
switch (var->type)
{
struct ECPGstruct_member *p;
@ -270,7 +270,7 @@ check_indicator(struct ECPGtype * var)
case ECPGt_struct:
case ECPGt_union:
for (p = var->u.members; p; p = p->next)
check_indicator(p->typ);
check_indicator(p->type);
break;
case ECPGt_array:

4
src/interfaces/ecpg/test/Makefile
View File

@ -1,10 +1,10 @@
# $Header: /cvsroot/pgsql/src/interfaces/ecpg/test/Makefile,v 1.32 2001/11/14 11:11:49 meskes Exp $
# $Header: /cvsroot/pgsql/src/interfaces/ecpg/test/Makefile,v 1.33 2001/12/23 12:17:41 meskes Exp $
subdir = src/interfaces/ecpg/test
top_builddir = ../../../..
include $(top_builddir)/src/Makefile.global
override CPPFLAGS := -I$(srcdir)/../include $(CPPFLAGS)
override CPPFLAGS := -I$(srcdir)/../include $(CPPFLAGS) -g
ECPG = ../preproc/ecpg -I$(srcdir)/../include

32
src/interfaces/ecpg/test/test1.pgc
View File

@ -1,4 +1,4 @@
#include <stdlib.h>
#include <string.h>
exec sql include sqlca;
@ -34,6 +34,18 @@ exec sql begin declare section;
int increment=100;
char name[AMOUNT][8];
char letter[AMOUNT][1];
struct name_letter_struct
{
char name[8];
int amount;
char letter;
} name_letter[AMOUNT];
struct ind_struct
{
short a;
short b;
short c;
} ind[AMOUNT];
char command[128];
char *connection="pm";
exec sql end declare section;
@ -113,16 +125,28 @@ exec sql end declare section;
exec sql at pm insert into "Test" (name, amount, letter) values (:n, :a, :l);
}
strcpy(msg, "commit");
exec sql at pm commit;
strcpy(msg, "select");
exec sql at :connection select name, amount, letter into :name, :amount, :letter from "Test";
printf("Database: pm\n");
printf("Database: %s\n", connection);
for (i=0, j=sqlca.sqlerrd[2]; i<j; i++)
printf("name[%d]=%8.8s\tamount[%d]=%d\tletter[%d]=%c\n", i, name[i], i, amount[i],i, letter[i][0]);
strcpy(msg, "select");
exec sql at pm select name, amount, letter into :name_letter from "Test";
strcpy(msg, "commit");
exec sql commit;
exec sql at pm commit;
strcpy(msg, "select");
exec sql at pm select name, amount, letter into :name_letter:ind from "Test";
printf("Database: pm\n");
for (i=0, j=sqlca.sqlerrd[2]; i<j; i++)
printf("name[%d]=%8.8s\tamount[%d]=%d\tletter[%d]=%c\n", i, name_letter[i].name, i, name_letter[i].amount,i, name_letter[i].letter);
/* Start automatic transactioning for connection main. */
exec sql set autocommit to on;

4
src/interfaces/ecpg/test/test2.pgc
View File

@ -69,9 +69,9 @@ exec sql end declare section;
strcpy(msg, "fetch");
exec sql fetch cur into :p:i, :married:ind_married, :children.integer:ind_children.smallint;
printf("%8.8s", personal.name.arr);
if (ind_personal.ind_birth.born >= 0)
if (i->ind_birth.born >= 0)
printf(", born %ld", personal.birth.born);
if (ind_personal.ind_birth.age >= 0)
if (i->ind_birth.age >= 0)
printf(", age = %d", personal.birth.age);
if ((long)ind_married >= 0)
printf(", married %s", married);