database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-11-22 12:22:45 +03:00
Code Activity

Ye-old pgindent run. Same 4-space tabs.

Browse Source
This commit is contained in:
Bruce Momjian
2000-04-12 17:17:23 +00:00
parent db4518729d
commit 52f77df613
434 changed files with 24799 additions and 21246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -14,7 +14,7 @@
/* first we have a set of ecpg messages, they start at 200 */
#define ECPG_UNSUPPORTED -200
#define ECPG_TOO_MANY_ARGUMENTS -201
#define ECPG_TOO_MANY_ARGUMENTS -201
#define ECPG_TOO_FEW_ARGUMENTS -202
#define ECPG_TOO_MANY_MATCHES -203
#define ECPG_INT_FORMAT -204

20
src/interfaces/ecpg/include/ecpglib.h
View File

@@ -17,27 +17,27 @@ extern "C"
bool ECPGprepare(int, char *, char *);
bool ECPGdeallocate(int, char *);
bool ECPGdeallocate_all(int);
char *ECPGprepared_statement(char *);
char *ECPGprepared_statement(char *);
void ECPGlog(const char *format,...);
/* print an error message */
void sqlprint(void);
/* define this for simplicity as well as compatibility */
#define SQLCODE sqlca.sqlcode
/* dynamic SQL */
bool ECPGdo_descriptor(int line,const char *connection,
const char *descriptor,const char *query);
bool ECPGdeallocate_desc(int line,const char *name);
bool ECPGallocate_desc(int line,const char *name);
bool ECPGdo_descriptor(int line, const char *connection,
const char *descriptor, const char *query);
bool ECPGdeallocate_desc(int line, const char *name);
bool ECPGallocate_desc(int line, const char *name);
void ECPGraise(int line, int code, char *str);
bool ECPGget_desc_header(int, char *, int *);
bool ECPGget_desc(int, char *, int, ...);
bool ECPGget_desc(int, char *, int,...);
#ifdef __cplusplus
}

2
src/interfaces/ecpg/include/ecpgtype.h
View File

@@ -50,7 +50,7 @@ extern "C"
ECPGt_NO_INDICATOR /* no indicator */
};
/* descriptor items */
/* descriptor items */
enum ECPGdtype
{
ECPGd_count,

23
src/interfaces/ecpg/include/sql3types.h
View File

@@ -2,12 +2,14 @@
*
* Copyright (c) 2000, Christof Petig <christof.petig@wtal.de>
*
* $Header: /cvsroot/pgsql/src/interfaces/ecpg/include/sql3types.h,v 1.3 2000/03/17 23:26:30 tgl Exp $
* $Header: /cvsroot/pgsql/src/interfaces/ecpg/include/sql3types.h,v 1.4 2000/04/12 17:17:01 momjian Exp $
*/
/* chapter 13.1 table 2: Codes used for SQL data types in Dynamic SQL */
enum { SQL3_CHARACTER=1,
enum
{
SQL3_CHARACTER = 1,
SQL3_NUMERIC,
SQL3_DECIMAL,
SQL3_INTEGER,
@@ -16,23 +18,26 @@ enum { SQL3_CHARACTER=1,
SQL3_REAL,
SQL3_DOUBLE_PRECISION,
SQL3_DATE_TIME_TIMESTAMP,
SQL3_INTERVAL, /* 10 */
SQL3_CHARACTER_VARYING=12,
SQL3_INTERVAL, /* 10 */
SQL3_CHARACTER_VARYING = 12,
SQL3_ENUMERATED,
SQL3_BIT,
SQL3_BIT_VARYING,
SQL3_BOOLEAN,
SQL3_abstract
/* the rest is xLOB stuff */
};
};
/* chapter 13.1 table 3: Codes associated with datetime data types in Dynamic SQL */
enum { SQL3_DDT_DATE=1,
enum
{
SQL3_DDT_DATE = 1,
SQL3_DDT_TIME,
SQL3_DDT_TIMESTAMP,
SQL3_DDT_TIME_WITH_TIME_ZONE,
SQL3_DDT_TIMESTAMP_WITH_TIME_ZONE,
SQL3_DDT_ILLEGAL /* not a datetime data type (not part of standard) */
};
SQL3_DDT_ILLEGAL /* not a datetime data type (not part of
* standard) */
};

3
src/interfaces/ecpg/include/sqlca.h
View File

@@ -21,7 +21,7 @@ extern "C"
char sqlerrp[8];
long sqlerrd[6];
/* Element 0: empty */
/* 1: OID of processed tuple if applicable */
/* 1: OID of processed tuple if applicable */
/* 2: number of rows processed */
/* after an INSERT, UPDATE or */
/* DELETE statement */
@@ -48,6 +48,7 @@ extern "C"
#ifdef __cplusplus
}
#endif
#endif

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

@@ -4,7 +4,8 @@
#include "extern.h"
#include <sqlca.h>
static struct connection *all_connections = NULL, *actual_connection = NULL;
static struct connection *all_connections = NULL,
*actual_connection = NULL;
struct connection *
get_connection(const char *connection_name)
@@ -58,10 +59,10 @@ ECPGsetcommit(int lineno, const char *mode, const char *connection_name)
PGresult *results;
if (!ecpg_init(con, connection_name, lineno))
return(false);
return (false);
ECPGlog("ECPGsetcommit line %d action = %s connection = %s\n", lineno, mode, con->name);
if (con->autocommit == true && strncmp(mode, "off", strlen("off")) == 0)
{
if (con->committed)
@@ -100,7 +101,7 @@ ECPGsetconn(int lineno, const char *connection_name)
struct connection *con = get_connection(connection_name);
if (!ecpg_init(con, connection_name, lineno))
return(false);
return (false);
actual_connection = con;
return true;
@@ -112,7 +113,7 @@ ECPGconnect(int lineno, const char *dbname, const char *user, const char *passwd
struct connection *this;
init_sqlca();
if ((this = (struct connection *) ecpg_alloc(sizeof(struct connection), lineno)) == NULL)
return false;
@@ -171,7 +172,7 @@ ECPGdisconnect(int lineno, const char *connection_name)
con = get_connection(connection_name);
if (!ecpg_init(con, connection_name, lineno))
return(false);
return (false);
else
ecpg_finish(con);
}

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

@@ -8,11 +8,11 @@
bool
get_data(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)
enum ECPGttype type, enum ECPGttype ind_type,
void *var, void *ind, long varcharsize, long offset,
bool isarray)
{
char *pval = (char *)PQgetvalue(results, act_tuple, act_field);
char *pval = (char *) PQgetvalue(results, act_tuple, act_field);
ECPGlog("get_data line %d: RESULT: %s\n", lineno, pval ? pval : "");
@@ -20,20 +20,20 @@ get_data(PGresult *results, int act_tuple, int act_field, int lineno,
/* let's check is it really is an array if it should be */
if (isarray)
{
if (*pval != '{')
if (*pval != '{')
{
ECPGlog("get_data data entry does not look like an array in line %d\n", lineno);
ECPGraise(lineno, ECPG_DATA_NOT_ARRAY, NULL);
return(false);
return (false);
}
else ++pval;
else
++pval;
}
/* We will have to decode the value */
/*
* check for null value and set indicator
* accordingly
* check for null value and set indicator accordingly
*/
switch (ind_type)
{
@@ -61,226 +61,226 @@ get_data(PGresult *results, int act_tuple, int act_field, int lineno,
return (false);
break;
}
do
{
switch (type)
{
long res;
unsigned long ures;
double dres;
char *scan_length;
{
switch (type)
{
long res;
unsigned long ures;
double dres;
char *scan_length;
case ECPGt_short:
case ECPGt_int:
case ECPGt_long:
if (pval)
{
res = strtol(pval, &scan_length, 10);
if ((isarray && *scan_length != ',' && *scan_length != '}')
|| (!isarray && *scan_length != '\0')) /* Garbage left */
case ECPGt_short:
case ECPGt_int:
case ECPGt_long:
if (pval)
{
ECPGraise(lineno, ECPG_INT_FORMAT, pval);
return (false);
res = 0L;
}
}
else
res = 0L;
switch (type)
{
case ECPGt_short:
((short *) var)[act_tuple] = (short) res;
break;
case ECPGt_int:
((int *) var)[act_tuple] = (int) res;
break;
case ECPGt_long:
((long *) var)[act_tuple] = res;
break;
default:
/* Cannot happen */
break;
}
break;
case ECPGt_unsigned_short:
case ECPGt_unsigned_int:
case ECPGt_unsigned_long:
if (pval)
{
ures = strtoul(pval, &scan_length, 10);
if ((isarray && *scan_length != ',' && *scan_length != '}')
|| (!isarray && *scan_length != '\0')) /* Garbage left */
{
ECPGraise(lineno, ECPG_UINT_FORMAT, pval);
return (false);
ures = 0L;
}
}
else
ures = 0L;
switch (type)
{
case ECPGt_unsigned_short:
((unsigned short *) var)[act_tuple] = (unsigned short) ures;
break;
case ECPGt_unsigned_int:
((unsigned int *) var)[act_tuple] = (unsigned int) ures;
break;
case ECPGt_unsigned_long:
((unsigned long *) var)[act_tuple] = ures;
break;
default:
/* Cannot happen */
break;
}
break;
case ECPGt_float:
case ECPGt_double:
if (pval)
{
dres = strtod(pval, &scan_length);
if ((isarray && *scan_length != ',' && *scan_length != '}')
|| (!isarray && *scan_length != '\0')) /* Garbage left */
{
ECPGraise(lineno, ECPG_FLOAT_FORMAT, pval);
return (false);
dres = 0.0;
}
}
else
dres = 0.0;
switch (type)
{
case ECPGt_float:
((float *) var)[act_tuple] = dres;
break;
case ECPGt_double:
((double *) var)[act_tuple] = dres;
break;
default:
/* Cannot happen */
break;
}
break;
case ECPGt_bool:
if (pval)
{
if (pval[0] == 'f' && pval[1] == '\0')
{
((char *) var)[act_tuple] = false;
break;
}
else if (pval[0] == 't' && pval[1] == '\0')
{
((char *) var)[act_tuple] = true;
break;
}
else if (pval[0] == '\0' && PQgetisnull(results, act_tuple, act_field))
{
/* NULL is valid */
break;
}
}
ECPGraise(lineno, ECPG_CONVERT_BOOL, pval);
return (false);
break;
case ECPGt_char:
case ECPGt_unsigned_char:
{
strncpy((char *) ((long) var + offset * act_tuple), pval, varcharsize);
if (varcharsize && varcharsize < strlen(pval))
{
/* truncation */
switch (ind_type)
res = strtol(pval, &scan_length, 10);
if ((isarray && *scan_length != ',' && *scan_length != '}')
|| (!isarray && *scan_length != '\0')) /* Garbage left */
{
case ECPGt_short:
case ECPGt_unsigned_short:
((short *) ind)[act_tuple] = varcharsize;
break;
case ECPGt_int:
case ECPGt_unsigned_int:
((int *) ind)[act_tuple] = varcharsize;
break;
case ECPGt_long:
case ECPGt_unsigned_long:
((long *) ind)[act_tuple] = varcharsize;
break;
default:
break;
ECPGraise(lineno, ECPG_INT_FORMAT, pval);
return (false);
res = 0L;
}
sqlca.sqlwarn[0] = sqlca.sqlwarn[1] = 'W';
}
}
break;
case ECPGt_varchar:
{
struct ECPGgeneric_varchar *variable =
(struct ECPGgeneric_varchar *) ((long) var + offset * act_tuple);
if (varcharsize == 0)
strncpy(variable->arr, pval, strlen(pval));
else
strncpy(variable->arr, pval, varcharsize);
res = 0L;
variable->len = strlen(pval);
if (varcharsize > 0 && variable->len > varcharsize)
switch (type)
{
/* truncation */
switch (ind_type)
{
case ECPGt_short:
case ECPGt_unsigned_short:
((short *) ind)[act_tuple] = varcharsize;
break;
case ECPGt_int:
case ECPGt_unsigned_int:
((int *) ind)[act_tuple] = varcharsize;
break;
case ECPGt_long:
case ECPGt_unsigned_long:
((long *) ind)[act_tuple] = varcharsize;
break;
default:
break;
}
sqlca.sqlwarn[0] = sqlca.sqlwarn[1] = 'W';
variable->len = varcharsize;
case ECPGt_short:
((short *) var)[act_tuple] = (short) res;
break;
case ECPGt_int:
((int *) var)[act_tuple] = (int) res;
break;
case ECPGt_long:
((long *) var)[act_tuple] = res;
break;
default:
/* Cannot happen */
break;
}
}
break;
break;
default:
ECPGraise(lineno, ECPG_UNSUPPORTED, ECPGtype_name(type));
return (false);
break;
}
if (isarray)
{
bool string = false;
/* set array to next entry */
++act_tuple;
/* set pval to the next entry */
for (; string || (*pval != ',' && *pval != '}'); ++pval)
if (*pval == '"')
string = string ? false : true;
if (*pval == ',')
++pval;
}
case ECPGt_unsigned_short:
case ECPGt_unsigned_int:
case ECPGt_unsigned_long:
if (pval)
{
ures = strtoul(pval, &scan_length, 10);
if ((isarray && *scan_length != ',' && *scan_length != '}')
|| (!isarray && *scan_length != '\0')) /* Garbage left */
{
ECPGraise(lineno, ECPG_UINT_FORMAT, pval);
return (false);
ures = 0L;
}
}
else
ures = 0L;
switch (type)
{
case ECPGt_unsigned_short:
((unsigned short *) var)[act_tuple] = (unsigned short) ures;
break;
case ECPGt_unsigned_int:
((unsigned int *) var)[act_tuple] = (unsigned int) ures;
break;
case ECPGt_unsigned_long:
((unsigned long *) var)[act_tuple] = ures;
break;
default:
/* Cannot happen */
break;
}
break;
case ECPGt_float:
case ECPGt_double:
if (pval)
{
dres = strtod(pval, &scan_length);
if ((isarray && *scan_length != ',' && *scan_length != '}')
|| (!isarray && *scan_length != '\0')) /* Garbage left */
{
ECPGraise(lineno, ECPG_FLOAT_FORMAT, pval);
return (false);
dres = 0.0;
}
}
else
dres = 0.0;
switch (type)
{
case ECPGt_float:
((float *) var)[act_tuple] = dres;
break;
case ECPGt_double:
((double *) var)[act_tuple] = dres;
break;
default:
/* Cannot happen */
break;
}
break;
case ECPGt_bool:
if (pval)
{
if (pval[0] == 'f' && pval[1] == '\0')
{
((char *) var)[act_tuple] = false;
break;
}
else if (pval[0] == 't' && pval[1] == '\0')
{
((char *) var)[act_tuple] = true;
break;
}
else if (pval[0] == '\0' && PQgetisnull(results, act_tuple, act_field))
{
/* NULL is valid */
break;
}
}
ECPGraise(lineno, ECPG_CONVERT_BOOL, pval);
return (false);
break;
case ECPGt_char:
case ECPGt_unsigned_char:
{
strncpy((char *) ((long) var + offset * act_tuple), pval, varcharsize);
if (varcharsize && varcharsize < strlen(pval))
{
/* truncation */
switch (ind_type)
{
case ECPGt_short:
case ECPGt_unsigned_short:
((short *) ind)[act_tuple] = varcharsize;
break;
case ECPGt_int:
case ECPGt_unsigned_int:
((int *) ind)[act_tuple] = varcharsize;
break;
case ECPGt_long:
case ECPGt_unsigned_long:
((long *) ind)[act_tuple] = varcharsize;
break;
default:
break;
}
sqlca.sqlwarn[0] = sqlca.sqlwarn[1] = 'W';
}
}
break;
case ECPGt_varchar:
{
struct ECPGgeneric_varchar *variable =
(struct ECPGgeneric_varchar *) ((long) var + offset * act_tuple);
if (varcharsize == 0)
strncpy(variable->arr, pval, strlen(pval));
else
strncpy(variable->arr, pval, varcharsize);
variable->len = strlen(pval);
if (varcharsize > 0 && variable->len > varcharsize)
{
/* truncation */
switch (ind_type)
{
case ECPGt_short:
case ECPGt_unsigned_short:
((short *) ind)[act_tuple] = varcharsize;
break;
case ECPGt_int:
case ECPGt_unsigned_int:
((int *) ind)[act_tuple] = varcharsize;
break;
case ECPGt_long:
case ECPGt_unsigned_long:
((long *) ind)[act_tuple] = varcharsize;
break;
default:
break;
}
sqlca.sqlwarn[0] = sqlca.sqlwarn[1] = 'W';
variable->len = varcharsize;
}
}
break;
default:
ECPGraise(lineno, ECPG_UNSUPPORTED, ECPGtype_name(type));
return (false);
break;
}
if (isarray)
{
bool string = false;
/* set array to next entry */
++act_tuple;
/* set pval to the next entry */
for (; string || (*pval != ',' && *pval != '}'); ++pval)
if (*pval == '"')
string = string ? false : true;
if (*pval == ',')
++pval;
}
} while (isarray && *pval != '}');
return (true);

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

@@ -6,265 +6,270 @@
struct descriptor
{
char *name;
PGresult *result;
struct descriptor *next;
} *all_descriptors = NULL;
char *name;
PGresult *result;
struct descriptor *next;
} *all_descriptors = NULL;
static PGresult
*ECPGresultByDescriptor(int line,const char *name)
*
ECPGresultByDescriptor(int line, const char *name)
{
struct descriptor *i;
for (i = all_descriptors; i != NULL; i = i->next)
{
if (!strcmp(name, i->name)) return i->result;
if (!strcmp(name, i->name))
return i->result;
}
ECPGraise(line, ECPG_UNKNOWN_DESCRIPTOR, name);
return NULL;
}
}
static unsigned int
ECPGDynamicType_DDT(Oid type)
{
switch(type)
{
case 1082: return SQL3_DDT_DATE; /* date */
case 1083: return SQL3_DDT_TIME; /* time */
case 1184: return SQL3_DDT_TIMESTAMP_WITH_TIME_ZONE; /* datetime */
case 1296: return SQL3_DDT_TIMESTAMP_WITH_TIME_ZONE; /* timestamp */
switch (type)
{
case 1082:return SQL3_DDT_DATE; /* date */
case 1083:
return SQL3_DDT_TIME; /* time */
case 1184:
return SQL3_DDT_TIMESTAMP_WITH_TIME_ZONE; /* datetime */
case 1296:
return SQL3_DDT_TIMESTAMP_WITH_TIME_ZONE; /* timestamp */
default:
return SQL3_DDT_ILLEGAL;
}
}
bool
ECPGget_desc_header(int lineno, char * desc_name, int *count)
ECPGget_desc_header(int lineno, char *desc_name, int *count)
{
PGresult *ECPGresult = ECPGresultByDescriptor(lineno, desc_name);
PGresult *ECPGresult = ECPGresultByDescriptor(lineno, desc_name);
if (!ECPGresult)
return false;
*count = PQnfields(ECPGresult);
ECPGlog("ECPGget_desc_header: found %d attributes.\n", *count);
return true;
}
}
static bool
get_int_item(int lineno, void *var, enum ECPGdtype vartype, int value)
{
switch (vartype)
{
case ECPGt_short:
*(short *)var = value;
break;
{
case ECPGt_short:
*(short *) var = value;
break;
case ECPGt_int:
*(int *)var = value;
break;
case ECPGt_long:
*(long *)var = value;
break;
case ECPGt_unsigned_short:
*(unsigned short *)var = value;
break;
*(int *) var = value;
break;
case ECPGt_long:
*(long *) var = value;
break;
case ECPGt_unsigned_short:
*(unsigned short *) var = value;
break;
case ECPGt_unsigned_int:
*(unsigned int *)var = value;
break;
case ECPGt_unsigned_long:
*(unsigned long *)var = value;
break;
case ECPGt_float:
*(float *)var = value;
break;
case ECPGt_double:
*(double *)var = value;
break;
default:
ECPGraise(lineno, ECPG_VAR_NOT_NUMERIC, NULL);
return (false);
*(unsigned int *) var = value;
break;
case ECPGt_unsigned_long:
*(unsigned long *) var = value;
break;
case ECPGt_float:
*(float *) var = value;
break;
case ECPGt_double:
*(double *) var = value;
break;
default:
ECPGraise(lineno, ECPG_VAR_NOT_NUMERIC, NULL);
return (false);
}
return(true);
return (true);
}
static bool
get_char_item(int lineno, void *var, enum ECPGdtype vartype, char *value, int varcharsize)
{
switch (vartype)
{
case ECPGt_char:
case ECPGt_unsigned_char:
strncpy((char *) var, value, varcharsize);
break;
case ECPGt_varchar:
{
struct ECPGgeneric_varchar *variable =
(struct ECPGgeneric_varchar *) var;
if (varcharsize == 0)
{
case ECPGt_char:
case ECPGt_unsigned_char:
strncpy((char *) var, value, varcharsize);
break;
case ECPGt_varchar:
{
struct ECPGgeneric_varchar *variable =
(struct ECPGgeneric_varchar *) var;
if (varcharsize == 0)
strncpy(variable->arr, value, strlen(value));
else
strncpy(variable->arr, value, varcharsize);
variable->len = strlen(value);
if (varcharsize > 0 && variable->len > varcharsize)
variable->len = varcharsize;
}
break;
default:
ECPGraise(lineno, ECPG_VAR_NOT_CHAR, NULL);
return (false);
else
strncpy(variable->arr, value, varcharsize);
variable->len = strlen(value);
if (varcharsize > 0 && variable->len > varcharsize)
variable->len = varcharsize;
}
break;
default:
ECPGraise(lineno, ECPG_VAR_NOT_CHAR, NULL);
return (false);
}
return(true);
return (true);
}
bool
ECPGget_desc(int lineno, char *desc_name, int index, ...)
ECPGget_desc(int lineno, char *desc_name, int index,...)
{
va_list args;
PGresult *ECPGresult = ECPGresultByDescriptor(lineno, desc_name);
enum ECPGdtype type;
va_list args;
PGresult *ECPGresult = ECPGresultByDescriptor(lineno, desc_name);
enum ECPGdtype type;
bool DataButNoIndicator = false;
va_start(args, index);
if (!ECPGresult)
return (false);
if (PQntuples(ECPGresult) < 1)
{
ECPGraise(lineno, ECPG_NOT_FOUND, NULL);
return (false);
}
if (index < 1 || index >PQnfields(ECPGresult))
{
ECPGraise(lineno, ECPG_INVALID_DESCRIPTOR_INDEX, NULL);
return (false);
}
va_start(args, index);
if (!ECPGresult)
return (false);
if (PQntuples(ECPGresult) < 1)
{
ECPGraise(lineno, ECPG_NOT_FOUND, NULL);
return (false);
}
if (index < 1 || index > PQnfields(ECPGresult))
{
ECPGraise(lineno, ECPG_INVALID_DESCRIPTOR_INDEX, NULL);
return (false);
}
ECPGlog("ECPGget_desc: reading items for tuple %d\n", index);
--index;
type = va_arg(args, enum ECPGdtype);
while (type != ECPGd_EODT)
{
char type_str[20];
long varcharsize;
long offset;
long arrsize;
enum ECPGttype vartype;
void *var;
vartype = va_arg(args, enum ECPGttype);
var = va_arg(args, void *);
varcharsize = va_arg(args, long);
arrsize = va_arg(args, long);
offset = va_arg(args, long);
switch (type)
{
case (ECPGd_indicator):
if (!get_int_item(lineno, var, vartype, -PQgetisnull(ECPGresult, 0, index)))
return (false);
ECPGlog("ECPGget_desc: INDICATOR = %d\n", -PQgetisnull(ECPGresult, 0, index));
break;
--index;
case ECPGd_name:
if (!get_char_item(lineno, var, vartype, PQfname(ECPGresult, index), varcharsize))
return(false);
ECPGlog("ECPGget_desc: NAME = %s\n", PQfname(ECPGresult, index));
break;
case ECPGd_nullable:
if (!get_int_item(lineno, var, vartype, 1))
return (false);
break;
case ECPGd_key_member:
if (!get_int_item(lineno, var, vartype, 0))
return (false);
break;
case ECPGd_scale:
if (!get_int_item(lineno, var, vartype, (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff))
return (false);
ECPGlog("ECPGget_desc: SCALE = %d\n", (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff);
break;
case ECPGd_precision:
if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) >> 16))
return (false);
ECPGlog("ECPGget_desc: PRECISION = %d\n", PQfmod(ECPGresult, index) >> 16);
break;
case ECPGd_ret_length:
type = va_arg(args, enum ECPGdtype);
while (type != ECPGd_EODT)
{
char type_str[20];
long varcharsize;
long offset;
long arrsize;
enum ECPGttype vartype;
void *var;
vartype = va_arg(args, enum ECPGttype);
var = va_arg(args, void *);
varcharsize = va_arg(args, long);
arrsize = va_arg(args, long);
offset = va_arg(args, long);
switch (type)
{
case (ECPGd_indicator):
if (!get_int_item(lineno, var, vartype, -PQgetisnull(ECPGresult, 0, index)))
return (false);
ECPGlog("ECPGget_desc: INDICATOR = %d\n", -PQgetisnull(ECPGresult, 0, index));
break;
case ECPGd_name:
if (!get_char_item(lineno, var, vartype, PQfname(ECPGresult, index), varcharsize))
return (false);
ECPGlog("ECPGget_desc: NAME = %s\n", PQfname(ECPGresult, index));
break;
case ECPGd_nullable:
if (!get_int_item(lineno, var, vartype, 1))
return (false);
break;
case ECPGd_key_member:
if (!get_int_item(lineno, var, vartype, 0))
return (false);
break;
case ECPGd_scale:
if (!get_int_item(lineno, var, vartype, (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff))
return (false);
ECPGlog("ECPGget_desc: SCALE = %d\n", (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff);
break;
case ECPGd_precision:
if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) >> 16))
return (false);
ECPGlog("ECPGget_desc: PRECISION = %d\n", PQfmod(ECPGresult, index) >> 16);
break;
case ECPGd_ret_length:
case ECPGd_ret_octet:
if (!get_int_item(lineno, var, vartype, PQgetlength(ECPGresult, 0, index)))
return (false);
ECPGlog("ECPGget_desc: RETURNED = %d\n", PQgetlength(ECPGresult, 0, index));
break;
return (false);
ECPGlog("ECPGget_desc: RETURNED = %d\n", PQgetlength(ECPGresult, 0, index));
break;
case ECPGd_octet:
if (!get_int_item(lineno, var, vartype, PQfsize(ECPGresult, index)))
return (false);
ECPGlog("ECPGget_desc: OCTET_LENGTH = %d\n", PQfsize(ECPGresult, index));
break;
return (false);
ECPGlog("ECPGget_desc: OCTET_LENGTH = %d\n", PQfsize(ECPGresult, index));
break;
case ECPGd_length:
if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) - VARHDRSZ))
return (false);
ECPGlog("ECPGget_desc: LENGTH = %d\n", PQfmod(ECPGresult, index) - VARHDRSZ);
break;
case ECPGd_type:
if (!get_int_item(lineno, var, vartype, ECPGDynamicType(PQftype(ECPGresult, index))))
return (false);
ECPGlog("ECPGget_desc: TYPE = %d\n", ECPGDynamicType(PQftype(ECPGresult, index)));
break;
return (false);
case ECPGd_di_code:
if (!get_int_item(lineno, var, vartype, ECPGDynamicType_DDT(PQftype(ECPGresult, index))))
return (false);
ECPGlog("ECPGget_desc: TYPE = %d\n", ECPGDynamicType_DDT(PQftype(ECPGresult, index)));
break;
ECPGlog("ECPGget_desc: LENGTH = %d\n", PQfmod(ECPGresult, index) - VARHDRSZ);
break;
case ECPGd_type:
if (!get_int_item(lineno, var, vartype, ECPGDynamicType(PQftype(ECPGresult, index))))
return (false);
ECPGlog("ECPGget_desc: TYPE = %d\n", ECPGDynamicType(PQftype(ECPGresult, index)));
break;
case ECPGd_di_code:
if (!get_int_item(lineno, var, vartype, ECPGDynamicType_DDT(PQftype(ECPGresult, index))))
return (false);
ECPGlog("ECPGget_desc: TYPE = %d\n", ECPGDynamicType_DDT(PQftype(ECPGresult, index)));
break;
case ECPGd_data:
if (!get_data(ECPGresult, 0, index, lineno, vartype, ECPGt_NO_INDICATOR, var, NULL, varcharsize, offset, false))
return (false);
break;
default:
snprintf(type_str, sizeof(type_str), "%d", type);
ECPGraise(lineno, ECPG_UNKNOWN_DESCRIPTOR_ITEM, type_str);
return(false);
}
type = va_arg(args, enum ECPGdtype);
}
if (DataButNoIndicator && PQgetisnull(ECPGresult, 0, index))
{
ECPGraise(lineno, ECPG_MISSING_INDICATOR, NULL);
return (false);
}
return (false);
return (true);
break;
default:
snprintf(type_str, sizeof(type_str), "%d", type);
ECPGraise(lineno, ECPG_UNKNOWN_DESCRIPTOR_ITEM, type_str);
return (false);
}
type = va_arg(args, enum ECPGdtype);
}
if (DataButNoIndicator && PQgetisnull(ECPGresult, 0, index))
{
ECPGraise(lineno, ECPG_MISSING_INDICATOR, NULL);
return (false);
}
return (true);
}
bool
@@ -272,7 +277,7 @@ ECPGdeallocate_desc(int line, const char *name)
{
struct descriptor *i;
struct descriptor **lastptr = &all_descriptors;
for (i = all_descriptors; i; lastptr = &i->next, i = i->next)
{
if (!strcmp(name, i->name))
@@ -286,15 +291,15 @@ ECPGdeallocate_desc(int line, const char *name)
}
ECPGraise(line, ECPG_UNKNOWN_DESCRIPTOR, name);
return false;
}
}
bool
ECPGallocate_desc(int line,const char *name)
ECPGallocate_desc(int line, const char *name)
{
struct descriptor *new = (struct descriptor *)malloc(sizeof(struct descriptor));
struct descriptor *new = (struct descriptor *) malloc(sizeof(struct descriptor));
new->next = all_descriptors;
new->name = malloc(strlen(name)+1);
new->name = malloc(strlen(name) + 1);
new->result = PQmakeEmptyPGresult(NULL, 0);
strcpy(new->name, name);
all_descriptors = new;

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

@@ -10,143 +10,143 @@ void
ECPGraise(int line, int code, char *str)
{
sqlca.sqlcode = code;
switch (code)
{
case ECPG_NOT_FOUND:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"No data found in line %d.", line);
break;
case ECPG_OUT_OF_MEMORY:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Out of memory in line %d.", line);
break;
case ECPG_UNSUPPORTED:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Unsupported type %s in line %d.", str, line);
break;
case ECPG_TOO_MANY_ARGUMENTS:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Too many arguments in line %d.", line);
break;
case ECPG_TOO_FEW_ARGUMENTS:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Too few arguments in line %d.", line);
break;
case ECPG_INT_FORMAT:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Not correctly formatted int type: %s line %d.", str, line);
break;
case ECPG_UINT_FORMAT:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Not correctly formatted unsigned type: %s in line %d.", str, line);
break;
case ECPG_FLOAT_FORMAT:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Not correctly formatted floating point type: %s in line %d.", str, line);
{
case ECPG_NOT_FOUND:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"No data found in line %d.", line);
break;
case ECPG_CONVERT_BOOL:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Unable to convert %s to bool on line %d.", str, line);
case ECPG_OUT_OF_MEMORY:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Out of memory in line %d.", line);
break;
case ECPG_EMPTY:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Empty query in line %d.", line);
case ECPG_UNSUPPORTED:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Unsupported type %s in line %d.", str, line);
break;
case ECPG_MISSING_INDICATOR:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"NULL value without indicator in line %d.", line);
break;
case ECPG_NO_ARRAY:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"variable is not an array in line %d.", line);
break;
case ECPG_DATA_NOT_ARRAY:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"data read from backend is not an array 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);
break;
case ECPG_NOT_CONN:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Not connected in line %d.", line);
case ECPG_TOO_MANY_ARGUMENTS:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Too many arguments in line %d.", line);
break;
case ECPG_INVALID_STMT:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Invalid statement name in line %d.", line);
case ECPG_TOO_FEW_ARGUMENTS:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Too few arguments in line %d.", line);
break;
case ECPG_UNKNOWN_DESCRIPTOR:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Sescriptor %s not found in line %d.", str, line);
case ECPG_INT_FORMAT:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Not correctly formatted int type: %s line %d.", str, line);
break;
case ECPG_INVALID_DESCRIPTOR_INDEX:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Sescriptor index out of range in line %d.", line);
case ECPG_UINT_FORMAT:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Not correctly formatted unsigned type: %s in line %d.", str, line);
break;
case ECPG_UNKNOWN_DESCRIPTOR_ITEM:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Unknown descriptor item %s in line %d.", str, line);
case ECPG_FLOAT_FORMAT:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Not correctly formatted floating point type: %s in line %d.", str, line);
break;
case ECPG_VAR_NOT_NUMERIC:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Variable is not a numeric type in line %d.", line);
case ECPG_CONVERT_BOOL:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Unable to convert %s to bool on line %d.", str, line);
break;
case ECPG_VAR_NOT_CHAR:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Variable is not a character type in line %d.", line);
case ECPG_EMPTY:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Empty query in line %d.", line);
break;
case ECPG_MISSING_INDICATOR:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"NULL value without indicator in line %d.", line);
break;
case ECPG_NO_ARRAY:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"variable is not an array in line %d.", line);
break;
case ECPG_DATA_NOT_ARRAY:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"data read from backend is not an array 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);
break;
case ECPG_NOT_CONN:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Not connected in line %d.", line);
break;
case ECPG_INVALID_STMT:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Invalid statement name in line %d.", line);
break;
case ECPG_UNKNOWN_DESCRIPTOR:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Sescriptor %s not found in line %d.", str, line);
break;
case ECPG_INVALID_DESCRIPTOR_INDEX:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Sescriptor index out of range in line %d.", line);
break;
case ECPG_UNKNOWN_DESCRIPTOR_ITEM:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Unknown descriptor item %s in line %d.", str, line);
break;
case ECPG_VAR_NOT_NUMERIC:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Variable is not a numeric type in line %d.", line);
break;
case ECPG_VAR_NOT_CHAR:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Variable is not a character type in line %d.", line);
break;
case ECPG_PGSQL:
/* strip trailing newline */
if (str[strlen(str)-1] == '\n')
str[strlen(str)-1] = '\0';
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"'%s' in line %d.", str, line);
if (str[strlen(str) - 1] == '\n')
str[strlen(str) - 1] = '\0';
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"'%s' in line %d.", str, line);
break;
case ECPG_TRANS:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Error in transaction processing in line %d.", line);
case ECPG_TRANS:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Error in transaction processing in line %d.", line);
break;
case ECPG_CONNECT:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"Could not connect to database %s in line %d.", str, line);
case ECPG_CONNECT:
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"Could not connect to database %s in line %d.", str, line);
break;
default:
snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
"SQL error #%d in line %d.", code, line);
snprintf(sqlca.sqlerrm.sqlerrmc, sizeof(sqlca.sqlerrm.sqlerrmc),
"SQL error #%d in line %d.", code, line);
break;
}
sqlca.sqlerrm.sqlerrml = strlen(sqlca.sqlerrm.sqlerrmc);
/* free all memory we have allocated for the user */
free_auto_mem();
/* free all memory we have allocated for the user */
free_auto_mem();
}
/* print out an error message */

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

@@ -54,9 +54,9 @@ struct variable
/* keep a list of memory we allocated for the user */
static struct auto_mem
{
void *pointer;
struct auto_mem *next;
} *auto_allocs = NULL;
void *pointer;
struct auto_mem *next;
} *auto_allocs = NULL;
static void
add_mem(void *ptr, int lineno)
@@ -67,20 +67,21 @@ add_mem(void *ptr, int lineno)
auto_allocs = am;
}
void free_auto_mem(void)
void
free_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);
/* 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;
}
@@ -245,7 +246,7 @@ next_insert(char *text)
bool string = false;
for (; *ptr != '\0' && (*ptr != '?' || string); ptr++)
if (*ptr == '\'' && *(ptr-1) != '\\')
if (*ptr == '\'' && *(ptr - 1) != '\\')
string = string ? false : true;
return (*ptr == '\0') ? NULL : ptr;
@@ -256,7 +257,8 @@ ECPGexecute(struct statement * stmt)
{
bool status = false;
char *copiedquery;
PGresult *results, *query;
PGresult *results,
*query;
PGnotify *notify;
struct variable *var;
@@ -275,7 +277,7 @@ ECPGexecute(struct statement * stmt)
char *mallocedval = NULL;
char *tobeinserted = NULL;
char *p;
char buff[20];
char buff[20];
/*
* Some special treatment is needed for records since we want
@@ -311,20 +313,20 @@ ECPGexecute(struct statement * stmt)
{
switch (var->type)
{
int element;
int element;
case ECPGt_short:
if (!(mallocedval = ecpg_alloc(var->arrsize * 20, stmt->lineno)))
return false;
if (var->arrsize > 1)
{
strncpy(mallocedval, "'{", sizeof("'{"));
strncpy(mallocedval, "'{", sizeof("'{"));
for (element = 0; element < var->arrsize; element++)
sprintf(mallocedval + strlen(mallocedval), "%hd,", ((short *) var->value)[element]);
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
}
else
sprintf(mallocedval, "%hd", *((short *) var->value));
@@ -338,12 +340,12 @@ ECPGexecute(struct statement * stmt)
if (var->arrsize > 1)
{
strncpy(mallocedval, "'{", sizeof("'{"));
strncpy(mallocedval, "'{", sizeof("'{"));
for (element = 0; element < var->arrsize; element++)
sprintf(mallocedval + strlen(mallocedval), "%d,", ((int *) var->value)[element]);
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
}
else
sprintf(mallocedval, "%d", *((int *) var->value));
@@ -357,12 +359,12 @@ ECPGexecute(struct statement * stmt)
if (var->arrsize > 1)
{
strncpy(mallocedval, "'{", sizeof("'{"));
strncpy(mallocedval, "'{", sizeof("'{"));
for (element = 0; element < var->arrsize; element++)
sprintf(mallocedval + strlen(mallocedval), "%hu,", ((unsigned short *) var->value)[element]);
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
}
else
sprintf(mallocedval, "%hu", *((unsigned short *) var->value));
@@ -376,12 +378,12 @@ ECPGexecute(struct statement * stmt)
if (var->arrsize > 1)
{
strncpy(mallocedval, "'{", sizeof("'{"));
strncpy(mallocedval, "'{", sizeof("'{"));
for (element = 0; element < var->arrsize; element++)
sprintf(mallocedval + strlen(mallocedval), "%u,", ((unsigned int *) var->value)[element]);
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
}
else
sprintf(mallocedval, "%u", *((unsigned int *) var->value));
@@ -392,15 +394,15 @@ ECPGexecute(struct statement * stmt)
case ECPGt_long:
if (!(mallocedval = ecpg_alloc(var->arrsize * 20, stmt->lineno)))
return false;
if (var->arrsize > 1)
{
strncpy(mallocedval, "'{", sizeof("'{"));
strncpy(mallocedval, "'{", sizeof("'{"));
for (element = 0; element < var->arrsize; element++)
sprintf(mallocedval + strlen(mallocedval), "%ld,", ((long *) var->value)[element]);
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
}
else
sprintf(mallocedval, "%ld", *((long *) var->value));
@@ -414,12 +416,12 @@ ECPGexecute(struct statement * stmt)
if (var->arrsize > 1)
{
strncpy(mallocedval, "'{", sizeof("'{"));
strncpy(mallocedval, "'{", sizeof("'{"));
for (element = 0; element < var->arrsize; element++)
sprintf(mallocedval + strlen(mallocedval), "%lu,", ((unsigned long *) var->value)[element]);
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
}
else
sprintf(mallocedval, "%lu", *((unsigned long *) var->value));
@@ -433,12 +435,12 @@ ECPGexecute(struct statement * stmt)
if (var->arrsize > 1)
{
strncpy(mallocedval, "'{", sizeof("'{"));
strncpy(mallocedval, "'{", sizeof("'{"));
for (element = 0; element < var->arrsize; element++)
sprintf(mallocedval + strlen(mallocedval), "%.14g,", ((float *) var->value)[element]);
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
}
else
sprintf(mallocedval, "%.14g", *((float *) var->value));
@@ -452,12 +454,12 @@ ECPGexecute(struct statement * stmt)
if (var->arrsize > 1)
{
strncpy(mallocedval, "'{", sizeof("'{"));
strncpy(mallocedval, "'{", sizeof("'{"));
for (element = 0; element < var->arrsize; element++)
sprintf(mallocedval + strlen(mallocedval), "%.14g,", ((double *) var->value)[element]);
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
}
else
sprintf(mallocedval, "%.14g", *((double *) var->value));
@@ -471,12 +473,12 @@ ECPGexecute(struct statement * stmt)
if (var->arrsize > 1)
{
strncpy(mallocedval, "'{", sizeof("'{"));
strncpy(mallocedval, "'{", sizeof("'{"));
for (element = 0; element < var->arrsize; element++)
sprintf(mallocedval + strlen(mallocedval), "%c,", (((char *) var->value)[element]) ? 't' : 'f');
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
strncpy(mallocedval + strlen(mallocedval) - 1, "}'", sizeof("}'"));
}
else
sprintf(mallocedval, "'%c'", (*((char *) var->value)) ? 't' : 'f');
@@ -541,7 +543,7 @@ ECPGexecute(struct statement * stmt)
default:
/* Not implemented yet */
ECPGraise(stmt->lineno, ECPG_UNSUPPORTED, (char *)ECPGtype_name(var->type));
ECPGraise(stmt->lineno, ECPG_UNSUPPORTED, (char *) ECPGtype_name(var->type));
return false;
break;
}
@@ -656,7 +658,7 @@ ECPGexecute(struct statement * stmt)
for (act_field = 0; act_field < nfields && status; act_field++)
{
char *array_query;
if (var == NULL)
{
ECPGlog("ECPGexecute line %d: Too few arguments.\n", stmt->lineno);
@@ -664,16 +666,21 @@ ECPGexecute(struct statement * stmt)
return (false);
}
array_query = (char *)ecpg_alloc(strlen("select typelem from pg_type where oid=") + 11, stmt -> lineno);
array_query = (char *) ecpg_alloc(strlen("select typelem from pg_type where oid=") + 11, stmt->lineno);
sprintf(array_query, "select typelem from pg_type where oid=%d", PQftype(results, act_field));
query = PQexec(stmt->connection->connection, array_query);
isarray = 0;
if (PQresultStatus(query) == PGRES_TUPLES_OK) {
isarray = atol((char *)PQgetvalue(query, 0, 0));
if (PQresultStatus(query) == PGRES_TUPLES_OK)
{
isarray = atol((char *) PQgetvalue(query, 0, 0));
if (ECPGDynamicType(PQftype(results, act_field)) == SQL3_CHARACTER ||
ECPGDynamicType(PQftype(results, act_field)) == SQL3_CHARACTER_VARYING)
ECPGDynamicType(PQftype(results, act_field)) == SQL3_CHARACTER_VARYING)
{
/* arrays of character strings are not yet implemented */
/*
* arrays of character strings are not yet
* implemented
*/
isarray = false;
}
ECPGlog("ECPGexecute line %d: TYPE database: %d C: %d array: %s\n", stmt->lineno, PQftype(results, act_field), var->type, isarray ? "yes" : "no");
@@ -682,14 +689,15 @@ ECPGexecute(struct statement * stmt)
if (!isarray)
{
/*
* if we don't have enough space, we cannot read all
* tuples
* if we don't have enough space, we cannot read
* all tuples
*/
if ((var->arrsize > 0 && ntuples > var->arrsize) || (var->ind_arrsize > 0 && ntuples > var->ind_arrsize))
{
ECPGlog("ECPGexecute line %d: Incorrect number of matches: %d don't fit into array of %d\n",
stmt->lineno, ntuples, var->arrsize);
stmt->lineno, ntuples, var->arrsize);
ECPGraise(stmt->lineno, ECPG_TOO_MANY_MATCHES, NULL);
status = false;
break;
@@ -697,6 +705,7 @@ ECPGexecute(struct statement * stmt)
}
else
{
/*
* since we read an array, the variable has to be
* an array too
@@ -707,9 +716,9 @@ ECPGexecute(struct statement * stmt)
ECPGraise(stmt->lineno, ECPG_NO_ARRAY, NULL);
status = false;
break;
}
}
}
/*
* allocate memory for NULL pointers
*/
@@ -744,13 +753,13 @@ ECPGexecute(struct statement * stmt)
*((void **) var->pointer) = var->value;
add_mem(var->value, stmt->lineno);
}
for (act_tuple = 0; act_tuple < ntuples && status; act_tuple++)
{
if (!get_data(results, act_tuple, act_field, stmt->lineno,
var->type, var->ind_type, var->value,
var->ind_value, var->varcharsize, var->offset, isarray))
status = false;
var->type, var->ind_type, var->value,
var->ind_value, var->varcharsize, var->offset, isarray))
status = false;
}
var = var->next;
}
@@ -811,13 +820,13 @@ ECPGexecute(struct statement * stmt)
}
bool
ECPGdo(int lineno, const char *connection_name, char *query, ...)
ECPGdo(int lineno, const char *connection_name, char *query,...)
{
va_list args;
struct statement *stmt;
struct connection *con = get_connection(connection_name);
bool status=true;
char *locale = setlocale(LC_NUMERIC, NULL);
va_list args;
struct statement *stmt;
struct connection *con = get_connection(connection_name);
bool status = true;
char *locale = setlocale(LC_NUMERIC, NULL);
/* Make sure we do NOT honor the locale for numeric input/output */
/* since the database wants teh standard decimal point */
@@ -826,7 +835,7 @@ ECPGdo(int lineno, const char *connection_name, char *query, ...)
if (!ecpg_init(con, connection_name, lineno))
{
setlocale(LC_NUMERIC, locale);
return(false);
return (false);
}
va_start(args, query);
@@ -859,26 +868,27 @@ ECPGdo(int lineno, const char *connection_name, char *query, ...)
*
* Copyright (c) 2000, Christof Petig <christof.petig@wtal.de>
*
* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/execute.c,v 1.5 2000/04/05 15:51:25 meskes Exp $
* $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/execute.c,v 1.6 2000/04/12 17:17:03 momjian Exp $
*/
PGconn *ECPG_internal_get_connection(char *name);
PGconn *ECPG_internal_get_connection(char *name);
extern struct descriptor
{
char *name;
PGresult *result;
struct descriptor *next;
} *all_descriptors;
char *name;
PGresult *result;
struct descriptor *next;
} *all_descriptors;
/* like ECPGexecute */
static bool execute_descriptor(int lineno,const char *query
,struct connection *con,PGresult **resultptr)
static bool
execute_descriptor(int lineno, const char *query
,struct connection * con, PGresult **resultptr)
{
bool status = false;
bool status = false;
PGresult *results;
PGnotify *notify;
/* Now the request is built. */
if (con->committed && !con->autocommit)
@@ -902,9 +912,12 @@ static bool execute_descriptor(int lineno,const char *query
ECPGraise(lineno, ECPG_PGSQL, PQerrorMessage(con->connection));
}
else
{ *resultptr=results;
{
*resultptr = results;
switch (PQresultStatus(results))
{ int ntuples;
{
int ntuples;
case PGRES_TUPLES_OK:
status = true;
sqlca.sqlerrd[2] = ntuples = PQntuples(results);
@@ -917,7 +930,7 @@ static bool execute_descriptor(int lineno,const char *query
break;
}
break;
#if 1 /* strictly these are not needed (yet) */
#if 1 /* strictly these are not needed (yet) */
case PGRES_EMPTY_QUERY:
/* do nothing */
ECPGraise(lineno, ECPG_EMPTY, NULL);
@@ -972,20 +985,22 @@ static bool execute_descriptor(int lineno,const char *query
}
/* like ECPGdo */
static bool do_descriptor2(int lineno,const char *connection_name,
PGresult **resultptr, const char *query)
static bool
do_descriptor2(int lineno, const char *connection_name,
PGresult **resultptr, const char *query)
{
struct connection *con = get_connection(connection_name);
bool status=true;
char *locale = setlocale(LC_NUMERIC, NULL);
bool status = true;
char *locale = setlocale(LC_NUMERIC, NULL);
/* Make sure we do NOT honor the locale for numeric input/output */
/* since the database wants teh standard decimal point */
setlocale(LC_NUMERIC, "C");
if (!ecpg_init(con, connection_name, lineno))
{ setlocale(LC_NUMERIC, locale);
return(false);
{
setlocale(LC_NUMERIC, locale);
return (false);
}
/* are we connected? */
@@ -997,33 +1012,38 @@ static bool do_descriptor2(int lineno,const char *connection_name,
return false;
}
status = execute_descriptor(lineno,query,con,resultptr);
status = execute_descriptor(lineno, query, con, resultptr);
/* and reset locale value so our application is not affected */
setlocale(LC_NUMERIC, locale);
return (status);
}
bool ECPGdo_descriptor(int line,const char *connection,
const char *descriptor,const char *query)
bool
ECPGdo_descriptor(int line, const char *connection,
const char *descriptor, const char *query)
{
struct descriptor *i;
for (i=all_descriptors;i!=NULL;i=i->next)
{ if (!strcmp(descriptor,i->name))
{
bool status;
for (i = all_descriptors; i != NULL; i = i->next)
{
if (!strcmp(descriptor, i->name))
{
bool status;
/* free previous result */
if (i->result) PQclear(i->result);
i->result=NULL;
status=do_descriptor2(line,connection,&i->result,query);
if (!i->result) PQmakeEmptyPGresult(NULL, 0);
if (i->result)
PQclear(i->result);
i->result = NULL;
status = do_descriptor2(line, connection, &i->result, query);
if (!i->result)
PQmakeEmptyPGresult(NULL, 0);
return (status);
}
}
}
ECPGraise(line, ECPG_UNKNOWN_DESCRIPTOR, (char *) descriptor);
return false;
}

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

@@ -3,14 +3,14 @@
/* Here are some methods used by the lib. */
/* Returns a pointer to a string containing a simple type name. */
void free_auto_mem(void);
void free_auto_mem(void);
bool get_data(PGresult *, int, int, int, enum ECPGttype type,
enum ECPGttype, void *, void *, long, long, bool);
enum ECPGttype, void *, void *, long, long, bool);
struct connection *get_connection(const char *);
void init_sqlca(void);
char *ecpg_alloc(long, int);
bool ecpg_init(const struct connection *, const char *, const int);
char *ecpg_strdup(const char *, int);
void init_sqlca(void);
char *ecpg_alloc(long, int);
bool ecpg_init(const struct connection *, const char *, const int);
char *ecpg_strdup(const char *, int);
const char *ECPGtype_name(enum ECPGttype);
unsigned int ECPGDynamicType(Oid);
@@ -24,20 +24,19 @@ struct ECPGgeneric_varchar
/* structure to store one statement */
struct statement
{
int lineno;
char *command;
struct connection *connection;
struct variable *inlist;
struct variable *outlist;
int lineno;
char *command;
struct connection *connection;
struct variable *inlist;
struct variable *outlist;
};
/* structure to store connections */
struct connection
{
char *name;
PGconn *connection;
bool committed;
int autocommit;
struct connection *next;
char *name;
PGconn *connection;
bool committed;
int autocommit;
struct connection *next;
};

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

@@ -27,7 +27,7 @@ init_sqlca(void)
}
bool
ecpg_init(const struct connection *con, const char * connection_name, const int lineno)
ecpg_init(const struct connection * con, const char *connection_name, const int lineno)
{
init_sqlca();
if (con == NULL)
@@ -35,7 +35,7 @@ ecpg_init(const struct connection *con, const char * connection_name, const int
ECPGraise(lineno, ECPG_NO_CONN, connection_name ? connection_name : "NULL");
return (false);
}
return (true);
}
@@ -45,7 +45,7 @@ ECPGstatus(int lineno, const char *connection_name)
struct connection *con = get_connection(connection_name);
if (!ecpg_init(con, connection_name, lineno))
return(false);
return (false);
/* are we connected? */
if (con->connection == NULL)
@@ -65,7 +65,7 @@ ECPGtrans(int lineno, const char *connection_name, const char *transaction)
struct connection *con = get_connection(connection_name);
if (!ecpg_init(con, connection_name, lineno))
return(false);
return (false);
ECPGlog("ECPGtrans line %d action = %s connection = %s\n", lineno, transaction, con->name);
@@ -79,14 +79,14 @@ ECPGtrans(int lineno, const char *connection_name, const char *transaction)
}
PQclear(res);
}
if (strcmp(transaction, "commit") == 0 || strcmp(transaction, "rollback") == 0)
{
con->committed = true;
/* deallocate all prepared statements */
if (!ECPGdeallocate_all(lineno))
return false;
return false;
}
return true;

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

@@ -8,10 +8,10 @@
static struct prepared_statement
{
char *name;
struct statement *stmt;
struct prepared_statement *next;
} *prep_stmts = NULL;
char *name;
struct statement *stmt;
struct prepared_statement *next;
} *prep_stmts = NULL;
static bool
isvarchar(unsigned char c)
@@ -47,7 +47,7 @@ replace_variables(char *text)
}
}
}
/* handle the EXEC SQL PREPARE statement */
bool
ECPGprepare(int lineno, char *name, char *variable)
@@ -117,7 +117,7 @@ ECPGdeallocate(int lineno, char *name)
prev->next = this->next;
else
prep_stmts = this->next;
free(this);
return true;
}
@@ -130,15 +130,15 @@ bool
ECPGdeallocate_all(int lineno)
{
/* deallocate all prepared statements */
while(prep_stmts != NULL)
{
bool b = ECPGdeallocate(lineno, prep_stmts->name);
if (!b)
while (prep_stmts != NULL)
{
bool b = ECPGdeallocate(lineno, prep_stmts->name);
if (!b)
return false;
}
return true;
}
return true;
}
/* return the prepared statement */

45
src/interfaces/ecpg/lib/typename.c
View File

@@ -12,7 +12,7 @@ ECPGtype_name(enum ECPGttype typ)
{
switch (typ)
{
case ECPGt_char:
case ECPGt_char:
return "char";
case ECPGt_unsigned_char:
return "unsigned char";
@@ -47,21 +47,34 @@ ECPGtype_name(enum ECPGttype typ)
unsigned int
ECPGDynamicType(Oid type)
{
switch(type)
switch (type)
{
case 16: return SQL3_BOOLEAN; /* bool */
case 21: return SQL3_SMALLINT; /* int2 */
case 23: return SQL3_INTEGER; /* int4 */
case 25: return SQL3_CHARACTER; /* text */
case 700: return SQL3_REAL; /* float4 */
case 701: return SQL3_DOUBLE_PRECISION; /* float8 */
case 1042: return SQL3_CHARACTER; /* bpchar */
case 1043: return SQL3_CHARACTER_VARYING; /* varchar */
case 1082: return SQL3_DATE_TIME_TIMESTAMP; /* date */
case 1083: return SQL3_DATE_TIME_TIMESTAMP; /* time */
case 1184: return SQL3_DATE_TIME_TIMESTAMP; /* datetime */
case 1296: return SQL3_DATE_TIME_TIMESTAMP; /* timestamp */
case 1700: return SQL3_NUMERIC; /* numeric */
default: return -type;
case 16:return SQL3_BOOLEAN; /* bool */
case 21:
return SQL3_SMALLINT; /* int2 */
case 23:
return SQL3_INTEGER;/* int4 */
case 25:
return SQL3_CHARACTER; /* text */
case 700:
return SQL3_REAL; /* float4 */
case 701:
return SQL3_DOUBLE_PRECISION; /* float8 */
case 1042:
return SQL3_CHARACTER; /* bpchar */
case 1043:
return SQL3_CHARACTER_VARYING; /* varchar */
case 1082:
return SQL3_DATE_TIME_TIMESTAMP; /* date */
case 1083:
return SQL3_DATE_TIME_TIMESTAMP; /* time */
case 1184:
return SQL3_DATE_TIME_TIMESTAMP; /* datetime */
case 1296:
return SQL3_DATE_TIME_TIMESTAMP; /* timestamp */
case 1700:
return SQL3_NUMERIC;/* numeric */
default:
return -type;
}
}

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

@@ -3,18 +3,19 @@
*/
#include "postgres.h"
#include "extern.h"
#include "extern.h"
/*
* assignment handling function (descriptor)
*/
struct assignment *assignments;
void push_assignment(char *var, enum ECPGdtype value)
void
push_assignment(char *var, enum ECPGdtype value)
{
struct assignment *new = (struct assignment *)mm_alloc(sizeof(struct assignment));
struct assignment *new = (struct assignment *) mm_alloc(sizeof(struct assignment));
new->next = assignments;
new->variable = mm_alloc(strlen(var) + 1);
strcpy(new->variable, var);
@@ -35,91 +36,94 @@ drop_assignments(void)
}
}
static void ECPGnumeric_lvalue(FILE *f,char *name)
static void
ECPGnumeric_lvalue(FILE *f, char *name)
{
const struct variable *v=find_variable(name);
const struct variable *v = find_variable(name);
switch(v->type->typ)
switch (v->type->typ)
{
case ECPGt_short:
case ECPGt_int:
case ECPGt_int:
case ECPGt_long:
case ECPGt_unsigned_short:
case ECPGt_unsigned_int:
case ECPGt_unsigned_long:
fputs(name,yyout);
fputs(name, yyout);
break;
default:
snprintf(errortext,sizeof errortext,"variable %s: numeric type needed"
,name);
mmerror(ET_ERROR,errortext);
snprintf(errortext, sizeof errortext, "variable %s: numeric type needed"
,name);
mmerror(ET_ERROR, errortext);
break;
}
}
}
/*
* descriptor name lookup
*/
static struct descriptor *descriptors;
void add_descriptor(char *name,char *connection)
void
add_descriptor(char *name, char *connection)
{
struct descriptor *new = (struct descriptor *)mm_alloc(sizeof(struct descriptor));
struct descriptor *new = (struct descriptor *) mm_alloc(sizeof(struct descriptor));
new->next = descriptors;
new->name = mm_alloc(strlen(name) + 1);
strcpy(new->name,name);
if (connection)
strcpy(new->name, name);
if (connection)
{
new->connection = mm_alloc(strlen(connection) + 1);
strcpy(new->connection, connection);
}
else new->connection = connection;
else
new->connection = connection;
descriptors = new;
}
void
drop_descriptor(char *name,char *connection)
drop_descriptor(char *name, char *connection)
{
struct descriptor *i;
struct descriptor **lastptr=&descriptors;
for (i=descriptors;i;lastptr=&i->next,i=i->next)
struct descriptor **lastptr = &descriptors;
for (i = descriptors; i; lastptr = &i->next, i = i->next)
{
if (!strcmp(name,i->name))
if (!strcmp(name, i->name))
{
if ((!connection && !i->connection)
|| (connection && i->connection
&& !strcmp(connection,i->connection)))
if ((!connection && !i->connection)
|| (connection && i->connection
&& !strcmp(connection, i->connection)))
{
*lastptr=i->next;
if (i->connection) free(i->connection);
*lastptr = i->next;
if (i->connection)
free(i->connection);
free(i->name);
free(i);
return;
}
}
}
snprintf(errortext,sizeof errortext,"unknown descriptor %s",name);
mmerror(ET_WARN,errortext);
snprintf(errortext, sizeof errortext, "unknown descriptor %s", name);
mmerror(ET_WARN, errortext);
}
struct descriptor
*lookup_descriptor(char *name, char *connection)
*
lookup_descriptor(char *name, char *connection)
{
struct descriptor *i;
for (i = descriptors; i; i = i->next)
{
if (!strcmp(name, i->name))
{
if ((!connection && !i->connection)
|| (connection && i->connection
&& !strcmp(connection,i->connection)))
{
if ((!connection && !i->connection)
|| (connection && i->connection
&& !strcmp(connection, i->connection)))
return i;
}
}
}
snprintf(errortext, sizeof errortext, "unknown descriptor %s", name);
@@ -136,14 +140,14 @@ output_get_descr_header(char *desc_name)
for (results = assignments; results != NULL; results = results->next)
{
if (results->value == ECPGd_count)
ECPGnumeric_lvalue(yyout,results->variable);
ECPGnumeric_lvalue(yyout, results->variable);
else
{
snprintf(errortext, sizeof errortext, "unknown descriptor header item '%d'", results->value);
mmerror(ET_WARN, errortext);
}
}
drop_assignments();
fprintf(yyout, "));\n");
whenever_action(3);
@@ -154,27 +158,27 @@ output_get_descr(char *desc_name, char *index)
{
struct assignment *results;
fprintf(yyout, "{ ECPGget_desc(%d,\"%s\",%s,", yylineno, desc_name, index);
fprintf(yyout, "{ ECPGget_desc(%d,\"%s\",%s,", yylineno, desc_name, index);
for (results = assignments; results != NULL; results = results->next)
{
const struct variable *v = find_variable(results->variable);
switch (results->value)
{
case ECPGd_nullable:
mmerror(ET_WARN,"nullable is always 1");
mmerror(ET_WARN, "nullable is always 1");
break;
case ECPGd_key_member:
mmerror(ET_WARN,"key_member is always 0");
mmerror(ET_WARN, "key_member is always 0");
break;
default:
break;
break;
}
fprintf(yyout, "%s,", get_dtype(results->value));
ECPGdump_a_type(yyout, v->name, v->type, NULL, NULL, NULL, NULL);
}
drop_assignments();
fputs("ECPGd_EODT);\n",yyout);
whenever_action(2|1);
fputs("ECPGd_EODT);\n", yyout);
whenever_action(2 | 1);
}

56
src/interfaces/ecpg/preproc/ecpg.c
View File

@@ -11,7 +11,8 @@
#include "extern.h"
int ret_value = OK, autocommit = 0;
int ret_value = OK,
autocommit = 0;
struct _include_path *include_paths = NULL;
struct cursor *cur = NULL;
struct typedefs *types = NULL;
@@ -85,8 +86,8 @@ main(int argc, char *const argv[])
verbose = true;
break;
case 'D':
add_preprocessor_define(optarg);
break;
add_preprocessor_define(optarg);
break;
default:
usage(argv[0]);
return ILLEGAL_OPTION;
@@ -102,7 +103,7 @@ main(int argc, char *const argv[])
fprintf(stderr, "End of search list.\n");
return OK;
}
if (optind >= argc) /* no files specified */
{
usage(argv[0]);
@@ -123,7 +124,7 @@ main(int argc, char *const argv[])
/* take care of relative paths */
ptr2ext = strrchr(input_filename, '/');
ptr2ext = (ptr2ext ? strrchr(ptr2ext, '.') : strrchr(input_filename, '.'));
/* no extension? */
if (ptr2ext == NULL)
{
@@ -137,7 +138,7 @@ main(int argc, char *const argv[])
ptr2ext[4] = '\0';
}
if (out_option == 0) /* calculate the output name */
if (out_option == 0)/* calculate the output name */
{
output_filename = strdup(input_filename);
@@ -177,7 +178,8 @@ main(int argc, char *const argv[])
for (ptr = cur; ptr != NULL;)
{
struct cursor *this = ptr;
struct arguments *l1, *l2;
struct arguments *l1,
*l2;
free(ptr->command);
free(ptr->connection);
@@ -198,26 +200,28 @@ main(int argc, char *const argv[])
cur = NULL;
/* remove non-pertinent old defines as well */
while ( defines && !defines->pertinent ) {
defptr = defines;
defines = defines->next;
while (defines && !defines->pertinent)
{
defptr = defines;
defines = defines->next;
free(defptr->new);
free(defptr->old);
free(defptr);
free(defptr->new);
free(defptr->old);
free(defptr);
}
for (defptr = defines; defptr != NULL; defptr = defptr->next )
for (defptr = defines; defptr != NULL; defptr = defptr->next)
{
struct _defines *this = defptr->next;
if ( this && !this->pertinent ) {
defptr->next = this->next;
struct _defines *this = defptr->next;
free(this->new);
free(this->old);
free(this);
}
if (this && !this->pertinent)
{
defptr->next = this->next;
free(this->new);
free(this->old);
free(this);
}
}
/* and old typedefs */
@@ -232,18 +236,18 @@ main(int argc, char *const argv[])
free(this);
}
types = NULL;
/* initialize whenever structures */
memset(&when_error, 0, sizeof(struct when));
memset(&when_nf, 0, sizeof(struct when));
memset(&when_warn, 0, sizeof(struct when));
/* and structure member lists */
memset(struct_member_list, 0, sizeof(struct_member_list));
/* finally the actual connection */
connection = NULL;
/* initialize lex */
lex_init();

3
src/interfaces/ecpg/preproc/ecpg_keywords.c
View File

@@ -61,7 +61,8 @@ static ScanKeyword ScanKeywords[] = {
{"section", SQL_SECTION},
{"short", SQL_SHORT},
{"signed", SQL_SIGNED},
{"sql",SQL_SQL}, /* strange thing, used for into sql descriptor MYDESC; */
{"sql", SQL_SQL}, /* strange thing, used for into sql
* descriptor MYDESC; */
{"sqlerror", SQL_SQLERROR},
{"sqlprint", SQL_SQLPRINT},
{"sqlwarning", SQL_SQLWARNING},

39
src/interfaces/ecpg/preproc/extern.h
View File

@@ -10,16 +10,19 @@
/* variables */
extern int braces_open,
autocommit,
ret_value,
struct_level;
autocommit,
ret_value,
struct_level;
extern char *descriptor_index;
extern char *descriptor_name;
extern char *connection;
extern char *input_filename;
extern char *yytext, errortext[128];
extern int yylineno, yyleng;
extern FILE *yyin, *yyout;
extern char *input_filename;
extern char *yytext,
errortext[128];
extern int yylineno,
yyleng;
extern FILE *yyin,
*yyout;
extern struct _include_path *include_paths;
extern struct cursor *cur;
@@ -29,7 +32,9 @@ extern struct ECPGtype ecpg_no_indicator;
extern struct variable no_indicator;
extern struct arguments *argsinsert;
extern struct arguments *argsresult;
extern struct when when_error, when_nf, when_warn;
extern struct when when_error,
when_nf,
when_warn;
extern struct ECPGstruct_member *struct_member_list[STRUCT_DEPTH];
extern struct descriptor *descriptors;
@@ -47,19 +52,19 @@ extern int yylex(void);
extern void yyerror(char *);
extern void *mm_alloc(size_t), *mm_realloc(void *, size_t);
extern char *mm_strdup(const char *);
extern void mmerror(enum errortype, char * );
extern void mmerror(enum errortype, char *);
extern ScanKeyword *ScanECPGKeywordLookup(char *);
extern ScanKeyword *ScanCKeywordLookup(char *);
extern void output_get_descr_header(char *);
extern void output_get_descr(char *, char *);
extern void push_assignment(char *, enum ECPGdtype);
extern struct variable * find_variable(char *);
extern struct variable *find_variable(char *);
extern void whenever_action(int);
extern void add_descriptor(char *,char *);
extern void drop_descriptor(char *,char *);
extern struct descriptor *lookup_descriptor(char *,char *);
extern void add_variable(struct arguments ** , struct variable * , struct variable *);
extern void append_variable(struct arguments ** , struct variable * , struct variable *);
extern void add_descriptor(char *, char *);
extern void drop_descriptor(char *, char *);
extern struct descriptor *lookup_descriptor(char *, char *);
extern void add_variable(struct arguments **, struct variable *, struct variable *);
extern void append_variable(struct arguments **, struct variable *, struct variable *);
extern void dump_variables(struct arguments *, int);
extern struct typedefs *get_typedef(char *);
extern void adjust_array(enum ECPGttype, int *, int *, int, int, bool);
@@ -67,13 +72,13 @@ extern void reset_variables(void);
extern void check_indicator(struct ECPGtype *);
extern void remove_variables(int);
extern struct variable *new_variable(const char *, struct ECPGtype *);
/* return codes */
#define OK 0
#define PARSE_ERROR -1
#define ILLEGAL_OPTION -2
#define INDICATOR_NOT_ARRAY -3
#define INDICATOR_NOT_ARRAY -3
#define NO_INCLUDE_FILE ENOENT
#define OUT_OF_MEMORY ENOMEM

97
src/interfaces/ecpg/preproc/output.c
View File

@@ -6,74 +6,83 @@
void
output_line_number()
{
if (input_filename)
fprintf(yyout, "\n#line %d \"%s\"\n", yylineno, input_filename);
if (input_filename)
fprintf(yyout, "\n#line %d \"%s\"\n", yylineno, input_filename);
}
void
output_simple_statement(char *cmd)
{
int i, j = strlen(cmd);;
int i,
j = strlen(cmd);;
/* do this char by char as we have to filter '\"' */
for (i = 0; i < j; i++) {
for (i = 0; i < j; i++)
{
if (cmd[i] != '"')
fputc(cmd[i], yyout);
else
fputs("\\\"", yyout);
}
output_line_number();
free(cmd);
free(cmd);
}
/*
* store the whenever action here
*/
struct when when_error, when_nf, when_warn;
struct when when_error,
when_nf,
when_warn;
static void
print_action(struct when *w)
print_action(struct when * w)
{
switch (w->code)
{
case W_SQLPRINT: fprintf(yyout, "sqlprint();");
break;
case W_GOTO: fprintf(yyout, "goto %s;", w->command);
break;
case W_DO: fprintf(yyout, "%s;", w->command);
break;
case W_STOP: fprintf(yyout, "exit (1);");
break;
case W_BREAK: fprintf(yyout, "break;");
break;
default: fprintf(yyout, "{/* %d not implemented yet */}", w->code);
break;
case W_SQLPRINT:fprintf(yyout, "sqlprint();");
break;
case W_GOTO:
fprintf(yyout, "goto %s;", w->command);
break;
case W_DO:
fprintf(yyout, "%s;", w->command);
break;
case W_STOP:
fprintf(yyout, "exit (1);");
break;
case W_BREAK:
fprintf(yyout, "break;");
break;
default:
fprintf(yyout, "{/* %d not implemented yet */}", w->code);
break;
}
}
void
whenever_action(int mode)
{
if ((mode&1) == 1 && when_nf.code != W_NOTHING)
if ((mode & 1) == 1 && when_nf.code != W_NOTHING)
{
output_line_number();
fprintf(yyout, "\nif (sqlca.sqlcode == ECPG_NOT_FOUND) ");
print_action(&when_nf);
}
if (when_warn.code != W_NOTHING)
{
{
output_line_number();
fprintf(yyout, "\nif (sqlca.sqlwarn[0] == 'W') ");
fprintf(yyout, "\nif (sqlca.sqlwarn[0] == 'W') ");
print_action(&when_warn);
}
}
if (when_error.code != W_NOTHING)
{
{
output_line_number();
fprintf(yyout, "\nif (sqlca.sqlcode < 0) ");
fprintf(yyout, "\nif (sqlca.sqlcode < 0) ");
print_action(&when_error);
}
}
if ((mode&2) == 2)
if ((mode & 2) == 2)
fputc('}', yyout);
output_line_number();
@@ -82,30 +91,33 @@ whenever_action(int mode)
char *
hashline_number(void)
{
if (input_filename)
{
char* line = mm_alloc(strlen("\n#line %d \"%s\"\n") + 21 + strlen(input_filename));
sprintf(line, "\n#line %d \"%s\"\n", yylineno, input_filename);
if (input_filename)
{
char *line = mm_alloc(strlen("\n#line %d \"%s\"\n") + 21 + strlen(input_filename));
return line;
}
sprintf(line, "\n#line %d \"%s\"\n", yylineno, input_filename);
return EMPTY;
return line;
}
return EMPTY;
}
void
output_statement(char * stmt, int mode, char *descriptor, char *con)
output_statement(char *stmt, int mode, char *descriptor, char *con)
{
int i, j = strlen(stmt);
int i,
j = strlen(stmt);
if (descriptor == NULL)
fprintf(yyout, "{ ECPGdo(__LINE__, %s, \"", con ? con : "NULL");
else
fprintf(yyout, "{ ECPGdo_descriptor(__LINE__, %s, \"%s\", \"",
con ? con : "NULL", descriptor);
fprintf(yyout, "{ ECPGdo_descriptor(__LINE__, %s, \"%s\", \"",
con ? con : "NULL", descriptor);
/* do this char by char as we have to filter '\"' */
for (i = 0; i < j; i++) {
for (i = 0; i < j; i++)
{
if (stmt[i] != '"')
fputc(stmt[i], yyout);
else
@@ -115,7 +127,7 @@ output_statement(char * stmt, int mode, char *descriptor, char *con)
if (descriptor == NULL)
{
fputs("\", ", yyout);
/* dump variables to C file */
dump_variables(argsinsert, 1);
fputs("ECPGt_EOIT, ", yyout);
@@ -125,7 +137,7 @@ output_statement(char * stmt, int mode, char *descriptor, char *con)
}
else
fputs("\");", yyout);
mode |= 2;
whenever_action(mode);
free(stmt);
@@ -134,4 +146,3 @@ output_statement(char * stmt, int mode, char *descriptor, char *con)
if (connection != NULL)
free(connection);
}

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

@@ -124,7 +124,7 @@ get_type(enum ECPGttype typ)
{
switch (typ)
{
case ECPGt_char:
case ECPGt_char:
return ("ECPGt_char");
break;
case ECPGt_unsigned_char:
@@ -163,7 +163,7 @@ get_type(enum ECPGttype typ)
return ("ECPGt_NO_INDICATOR");
break;
case ECPGt_char_variable: /* string that should not be
* quoted */
* quoted */
return ("ECPGt_char_variable");
break;
default:
@@ -200,10 +200,10 @@ ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype * typ, const char *in
{
switch (typ->typ)
{
case ECPGt_array:
case ECPGt_array:
switch (typ->u.element->typ)
{
case ECPGt_array:
case ECPGt_array:
yyerror("No nested arrays allowed (except strings)"); /* array of array */
break;
case ECPGt_struct:
@@ -269,7 +269,11 @@ ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
switch (typ)
{
case ECPGt_varchar:
/* we have to use the pointer except for arrays with given bounds */
/*
* we have to use the pointer except for arrays with given
* bounds
*/
if (arrsize > 0)
sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
else
@@ -280,7 +284,11 @@ ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
case ECPGt_char:
case ECPGt_unsigned_char:
case ECPGt_char_variable:
/* we have to use the pointer except for arrays with given bounds */
/*
* we have to use the pointer except for arrays with given
* bounds
*/
if (varcharsize > 1 || arrsize > 0)
sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
else
@@ -289,7 +297,11 @@ ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
sprintf(offset, "%ld*sizeof(char)", varcharsize == 0 ? 1 : varcharsize);
break;
default:
/* we have to use the pointer except for arrays with given bounds */
/*
* we have to use the pointer except for arrays with given
* bounds
*/
if (arrsize > 0)
sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
else
@@ -375,10 +387,10 @@ ECPGfree_type(struct ECPGtype * typ)
{
switch (typ->typ)
{
case ECPGt_array:
case ECPGt_array:
switch (typ->u.element->typ)
{
case ECPGt_array:
case ECPGt_array:
yyerror("internal error, found multi-dimensional array\n");
break;
case ECPGt_struct:
@@ -412,7 +424,7 @@ get_dtype(enum ECPGdtype typ)
{
switch (typ)
{
case ECPGd_count:
case ECPGd_count:
return ("ECPGd_countr");
break;
case ECPGd_data:
@@ -450,10 +462,10 @@ get_dtype(enum ECPGdtype typ)
case ECPGd_ret_octet:
return ("ECPGd_ret_octet");
break;
case ECPGd_scale:
case ECPGd_scale:
return ("ECPGd_scale");
break;
case ECPGd_type:
case ECPGd_type:
return ("ECPGd_type");
break;
default:

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

@@ -119,7 +119,7 @@ struct _defines
{
char *old;
char *new;
int pertinent;
int pertinent;
struct _defines *next;
};
@@ -141,22 +141,25 @@ struct arguments
struct descriptor
{
char *name;
char *connection;
char *name;
char *connection;
struct descriptor *next;
};
struct assignment
{
char *variable;
enum ECPGdtype value;
struct assignment *next;
{
char *variable;
enum ECPGdtype value;
struct assignment *next;
};
enum errortype {ET_WARN, ET_ERROR, ET_FATAL};
enum errortype
{
ET_WARN, ET_ERROR, ET_FATAL
};
struct fetch_desc
{
char *str;
char *name;
char *str;
char *name;
};

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

@@ -2,174 +2,177 @@
#include "extern.h"
struct variable * allvariables = NULL;
struct variable *allvariables = NULL;
struct variable *
new_variable(const char * name, struct ECPGtype * type)
new_variable(const char *name, struct ECPGtype * type)
{
struct variable * p = (struct variable*) mm_alloc(sizeof(struct variable));
struct variable *p = (struct variable *) mm_alloc(sizeof(struct variable));
p->name = mm_strdup(name);
p->type = type;
p->brace_level = braces_open;
p->name = mm_strdup(name);
p->type = type;
p->brace_level = braces_open;
p->next = allvariables;
allvariables = p;
p->next = allvariables;
allvariables = p;
return(p);
return (p);
}
static struct variable *
find_struct_member(char *name, char *str, struct ECPGstruct_member *members)
find_struct_member(char *name, char *str, struct ECPGstruct_member * members)
{
char *next = strchr(++str, '.'), c = '\0';
char *next = strchr(++str, '.'),
c = '\0';
if (next != NULL)
{
c = *next;
if (next != NULL)
{
c = *next;
*next = '\0';
}
for (; members; members = members->next)
{
if (strcmp(members->name, str) == 0)
{
if (c == '\0')
{
/* found the end */
switch (members->typ->typ)
{
case ECPGt_array:
return (new_variable(name, ECPGmake_array_type(members->typ->u.element, members->typ->size)));
case ECPGt_struct:
case ECPGt_union:
return (new_variable(name, ECPGmake_struct_type(members->typ->u.members, members->typ->typ)));
default:
return (new_variable(name, ECPGmake_simple_type(members->typ->typ, members->typ->size)));
}
}
else
{
*next = c;
if (c == '-')
{
next++;
return (find_struct_member(name, next, members->typ->u.element->u.members));
}
else
return (find_struct_member(name, next, members->typ->u.members));
}
}
}
return (NULL);
}
static struct variable *
find_struct(char *name, char *next)
{
struct variable *p;
char c = *next;
/* first get the mother structure entry */
*next = '\0';
}
p = find_variable(name);
for (; members; members = members->next)
{
if (strcmp(members->name, str) == 0)
if (c == '-')
{
if (c == '\0')
if (p->type->typ != ECPGt_struct && p->type->typ != ECPGt_union)
{
/* found the end */
switch (members->typ->typ)
{
case ECPGt_array:
return(new_variable(name, ECPGmake_array_type(members->typ->u.element, members->typ->size)));
case ECPGt_struct:
case ECPGt_union:
return(new_variable(name, ECPGmake_struct_type(members->typ->u.members, members->typ->typ)));
default:
return(new_variable(name, ECPGmake_simple_type(members->typ->typ, members->typ->size)));
}
sprintf(errortext, "variable %s is not a pointer", name);
mmerror(ET_FATAL, errortext);
}
else
{
*next = c;
if (c == '-')
{
next++;
return(find_struct_member(name, next, members->typ->u.element->u.members));
}
else return(find_struct_member(name, next, members->typ->u.members));
}
}
}
return(NULL);
if (p->type->u.element->typ != ECPGt_struct && p->type->u.element->typ != ECPGt_union)
{
sprintf(errortext, "variable %s is not a pointer to a structure or a union", name);
mmerror(ET_FATAL, errortext);
}
/* restore the name, we will need it later on */
*next = c;
next++;
return find_struct_member(name, next, p->type->u.element->u.members);
}
else
{
if (p->type->typ != ECPGt_struct && p->type->typ != ECPGt_union)
{
sprintf(errortext, "variable %s is neither a structure nor a union", name);
mmerror(ET_FATAL, errortext);
}
/* restore the name, we will need it later on */
*next = c;
return find_struct_member(name, next, p->type->u.members);
}
}
static struct variable *
find_struct(char * name, char *next)
find_simple(char *name)
{
struct variable * p;
char c = *next;
struct variable *p;
/* first get the mother structure entry */
*next = '\0';
p = find_variable(name);
if (c == '-')
{
if (p->type->typ != ECPGt_struct && p->type->typ != ECPGt_union)
{
sprintf(errortext, "variable %s is not a pointer", name);
mmerror(ET_FATAL, errortext);
}
if (p->type->u.element->typ != ECPGt_struct && p->type->u.element->typ != ECPGt_union)
{
sprintf(errortext, "variable %s is not a pointer to a structure or a union", name);
mmerror(ET_FATAL, errortext);
}
/* restore the name, we will need it later on */
*next = c;
next++;
return find_struct_member(name, next, p->type->u.element->u.members);
}
else
{
if (p->type->typ != ECPGt_struct && p->type->typ != ECPGt_union)
for (p = allvariables; p; p = p->next)
{
sprintf(errortext, "variable %s is neither a structure nor a union", name);
mmerror(ET_FATAL, errortext);
if (strcmp(p->name, name) == 0)
return p;
}
/* restore the name, we will need it later on */
*next = c;
return find_struct_member(name, next, p->type->u.members);
}
}
static struct variable *
find_simple(char * name)
{
struct variable * p;
for (p = allvariables; p; p = p->next)
{
if (strcmp(p->name, name) == 0)
return p;
}
return(NULL);
return (NULL);
}
/* Note that this function will end the program in case of an unknown */
/* variable */
struct variable *
find_variable(char * name)
find_variable(char *name)
{
char * next;
struct variable * p;
char *next;
struct variable *p;
if ((next = strchr(name, '.')) != NULL)
p = find_struct(name, next);
else if ((next = strstr(name, "->")) != NULL)
p = find_struct(name, next);
else
p = find_simple(name);
if ((next = strchr(name, '.')) != NULL)
p = find_struct(name, next);
else if ((next = strstr(name, "->")) != NULL)
p = find_struct(name, next);
else
p = find_simple(name);
if (p == NULL)
{
sprintf(errortext, "The variable %s is not declared", name);
mmerror(ET_FATAL, errortext);
}
if (p == NULL)
{
sprintf(errortext, "The variable %s is not declared", name);
mmerror(ET_FATAL, errortext);
}
return(p);
return (p);
}
void
remove_variables(int brace_level)
{
struct variable * p, *prev;
struct variable *p,
*prev;
for (p = prev = allvariables; p; p = p ? p->next : NULL)
{
if (p->brace_level >= brace_level)
for (p = prev = allvariables; p; p = p ? p->next : NULL)
{
/* remove it */
if (p == allvariables)
prev = allvariables = p->next;
else
prev->next = p->next;
if (p->brace_level >= brace_level)
{
/* remove it */
if (p == allvariables)
prev = allvariables = p->next;
else
prev->next = p->next;
ECPGfree_type(p->type);
free(p->name);
free(p);
p = prev;
ECPGfree_type(p->type);
free(p->name);
free(p);
p = prev;
}
else
prev = p;
}
else
prev = p;
}
}
@@ -179,44 +182,45 @@ remove_variables(int brace_level)
* I will make two lists for them.
*/
struct arguments * argsinsert = NULL;
struct arguments * argsresult = NULL;
struct arguments *argsinsert = NULL;
struct arguments *argsresult = NULL;
void
reset_variables(void)
{
argsinsert = NULL;
argsresult = NULL;
argsinsert = NULL;
argsresult = NULL;
}
/* Insert a new variable into our request list. */
void
add_variable(struct arguments ** list, struct variable * var, struct variable * ind)
{
struct arguments *p = (struct arguments *)mm_alloc(sizeof(struct arguments));
p->variable = var;
p->indicator = ind;
p->next = *list;
*list = p;
struct arguments *p = (struct arguments *) mm_alloc(sizeof(struct arguments));
p->variable = var;
p->indicator = ind;
p->next = *list;
*list = p;
}
/* Append a new variable to our request list. */
void
append_variable(struct arguments ** list, struct variable * var, struct variable * ind)
{
struct arguments *p, *new = (struct arguments *)mm_alloc(sizeof(struct arguments));
struct arguments *p,
*new = (struct arguments *) mm_alloc(sizeof(struct arguments));
for (p = *list; p && p->next; p = p->next);
new->variable = var;
new->indicator = ind;
new->next = NULL;
if (p)
p->next = new;
else
*list = new;
for (p = *list; p && p->next; p = p->next);
new->variable = var;
new->indicator = ind;
new->next = NULL;
if (p)
p->next = new;
else
*list = new;
}
/* Dump out a list of all the variable on this list.
@@ -226,33 +230,32 @@ append_variable(struct arguments ** list, struct variable * var, struct variable
void
dump_variables(struct arguments * list, int mode)
{
if (list == NULL)
{
return;
}
if (list == NULL)
return;
/* The list is build up from the beginning so lets first dump the
end of the list:
*/
/*
* The list is build up from the beginning so lets first dump the end
* of the list:
*/
dump_variables(list->next, mode);
dump_variables(list->next, 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);
/* 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);
/* Then release the list element. */
if (mode != 0)
free(list);
/* Then release the list element. */
if (mode != 0)
free(list);
}
void
check_indicator(struct ECPGtype *var)
check_indicator(struct ECPGtype * var)
{
/* make sure this is a valid indicator variable */
switch (var->typ)
{
struct ECPGstruct_member *p;
struct ECPGstruct_member *p;
case ECPGt_short:
case ECPGt_int:
@@ -271,7 +274,7 @@ check_indicator(struct ECPGtype *var)
case ECPGt_array:
check_indicator(var->u.element);
break;
default:
default:
mmerror(ET_ERROR, "indicator variable must be integer type");
break;
}
@@ -289,20 +292,20 @@ get_typedef(char *name)
mmerror(ET_FATAL, errortext);
}
return(this);
return (this);
}
void
adjust_array(enum ECPGttype type_enum, int *dimension, int *length, int type_dimension, int type_index, bool pointer)
{
if (type_index >= 0)
if (type_index >= 0)
{
if (*length >= 0)
mmerror(ET_FATAL, "No multi-dimensional array support");
mmerror(ET_FATAL, "No multi-dimensional array support");
*length = type_index;
}
if (type_dimension >= 0)
{
if (*dimension >= 0 && *length >= 0)
@@ -319,56 +322,57 @@ adjust_array(enum ECPGttype type_enum, int *dimension, int *length, int type_dim
switch (type_enum)
{
case ECPGt_struct:
case ECPGt_union:
/* pointer has to get dimension 0 */
if (pointer)
{
*length = *dimension;
*dimension = 0;
}
case ECPGt_struct:
case ECPGt_union:
/* pointer has to get dimension 0 */
if (pointer)
{
*length = *dimension;
*dimension = 0;
}
if (*length >= 0)
mmerror(ET_FATAL, "No multi-dimensional array support for structures");
if (*length >= 0)
mmerror(ET_FATAL, "No multi-dimensional array support for structures");
break;
case ECPGt_varchar:
/* pointer has to get dimension 0 */
if (pointer)
*dimension = 0;
break;
case ECPGt_varchar:
/* pointer has to get dimension 0 */
if (pointer)
*dimension = 0;
/* one index is the string length */
if (*length < 0)
{
*length = *dimension;
*dimension = -1;
}
/* one index is the string length */
if (*length < 0)
{
*length = *dimension;
*dimension = -1;
}
break;
case ECPGt_char:
case ECPGt_unsigned_char:
/* pointer has to get length 0 */
if (pointer)
*length=0;
break;
case ECPGt_char:
case ECPGt_unsigned_char:
/* pointer has to get length 0 */
if (pointer)
*length = 0;
/* one index is the string length */
if (*length < 0)
{
*length = (*dimension < 0) ? 1 : *dimension;
*dimension = -1;
}
/* one index is the string length */
if (*length < 0)
{
*length = (*dimension < 0) ? 1 : *dimension;
*dimension = -1;
}
break;
default:
/* a pointer has dimension = 0 */
if (pointer) {
*length = *dimension;
*dimension = 0;
}
break;
default:
/* a pointer has dimension = 0 */
if (pointer)
{
*length = *dimension;
*dimension = 0;
}
if (*length >= 0)
mmerror(ET_FATAL, "No multi-dimensional array support for simple data types");
if (*length >= 0)
mmerror(ET_FATAL, "No multi-dimensional array support for simple data types");
break;
break;
}
}

26
src/interfaces/ecpg/test/header_test.h
View File

@@ -1,26 +1,32 @@
exec sql include sqlca;
void Finish(msg)
void
Finish(msg)
{
fprintf(stderr, "Error in statement '%s':\n", msg);
sqlprint();
/* finish transaction */
exec sql rollback;
exec sql rollback;
/* and remove test table */
exec sql drop table meskes;
exec sql commit;
exec sql commit;
exec sql disconnect;
exec sql disconnect;
exit(-1);
}
void warn(void)
void
warn(void)
{
fprintf(stderr, "Warning: At least one column was truncated\n");
}
exec sql whenever sqlerror do Finish(msg);
exec sql whenever sqlwarning do warn();
exec sql whenever sqlerror
do
Finish(msg);
exec sql whenever sqlwarning
do
warn();