retval = false;
}
- return (retval);
+ return retval;
}
l--;
i++;
}
- return (ml); /* lower == upper */
+ return ml; /* lower == upper */
}
else
retval = entry;
- return (retval);
+ return retval;
}
default:
retval = FALSE;
}
- return (retval);
+ return retval;
}
bool
default:
retval = FALSE;
}
- return (retval);
+ return retval;
}
NDBOX *
retval = cube_union_v0(r1, r2);
*sizep = VARSIZE(retval);
- return (retval);
+ return retval;
}
SET_POINT_BIT(result);
}
- return (result);
+ return result;
}
Datum
int i;
if ((a == NULL) || (b == NULL))
- return (FALSE);
+ return FALSE;
if (DIM(a) < DIM(b))
{
for (i = DIM(a); i < DIM(b); i++)
{
if (LL_COORD(b, i) != 0)
- return (FALSE);
+ return FALSE;
if (UR_COORD(b, i) != 0)
- return (FALSE);
+ return FALSE;
}
}
{
if (Min(LL_COORD(a, i), UR_COORD(a, i)) >
Min(LL_COORD(b, i), UR_COORD(b, i)))
- return (FALSE);
+ return FALSE;
if (Max(LL_COORD(a, i), UR_COORD(a, i)) <
Max(LL_COORD(b, i), UR_COORD(b, i)))
- return (FALSE);
+ return FALSE;
}
- return (TRUE);
+ return TRUE;
}
Datum
int i;
if ((a == NULL) || (b == NULL))
- return (FALSE);
+ return FALSE;
/* swap the box pointers if needed */
if (DIM(a) < DIM(b))
for (i = 0; i < DIM(b); i++)
{
if (Min(LL_COORD(a, i), UR_COORD(a, i)) > Max(LL_COORD(b, i), UR_COORD(b, i)))
- return (FALSE);
+ return FALSE;
if (Max(LL_COORD(a, i), UR_COORD(a, i)) < Min(LL_COORD(b, i), UR_COORD(b, i)))
- return (FALSE);
+ return FALSE;
}
/* compare to zero those dimensions in (a) absent in (b) */
for (i = DIM(b); i < DIM(a); i++)
{
if (Min(LL_COORD(a, i), UR_COORD(a, i)) > 0)
- return (FALSE);
+ return FALSE;
if (Max(LL_COORD(a, i), UR_COORD(a, i)) < 0)
- return (FALSE);
+ return FALSE;
}
- return (TRUE);
+ return TRUE;
}
return (Min(a1, a2) - Max(b1, b2));
/* the rest are all sorts of intersections */
- return (0.0);
+ return 0.0;
}
/* Test if a box is also a point */
}
appendStringInfoChar(&buf, ')');
- return (buf.data);
+ return buf.data;
}
static char *
appendStringInfoString(&buf, " IS NULL");
}
- return (buf.data);
+ return buf.data;
}
static char *
appendStringInfoString(&buf, " IS NULL");
}
- return (buf.data);
+ return buf.data;
}
/*
key, HASH_FIND, NULL);
if (hentry)
- return (hentry->rconn);
+ return hentry->rconn;
- return (NULL);
+ return NULL;
}
static HTAB *
{
StopMiddle = StopLow + (StopHigh - StopLow) / 2;
if (*StopMiddle == item->val)
- return (true);
+ return true;
else if (*StopMiddle < item->val)
StopLow = StopMiddle + 1;
else
return (*chkcond) (checkval, curitem);
else if (curitem->val == (int32) '!')
{
- return (calcnot) ?
+ return calcnot ?
((execute(curitem - 1, checkval, calcnot, chkcond)) ? false : true)
: true;
}
return (*chkcond) (checkval, curitem);
else if (curitem->val == (int32) '!')
{
- return (calcnot) ?
+ return calcnot ?
((ltree_execute(curitem + 1, checkval, calcnot, chkcond)) ? false : true)
: true;
}
ascii_to_bin(char ch)
{
if (ch > 'z')
- return (0);
+ return 0;
if (ch >= 'a')
return (ch - 'a' + 38);
if (ch > 'Z')
- return (0);
+ return 0;
if (ch >= 'A')
return (ch - 'A' + 12);
if (ch > '9')
- return (0);
+ return 0;
if (ch >= '.')
return (ch - '.');
- return (0);
+ return 0;
}
static void
* (which is weak and has bad parity anyway) in order to simplify the
* starting conditions.
*/
- return (0);
+ return 0;
}
old_rawkey0 = rawkey0;
old_rawkey1 = rawkey1;
| comp_maskr[6][(t1 >> 7) & 0x7f]
| comp_maskr[7][t1 & 0x7f];
}
- return (0);
+ return 0;
}
static int
int round;
if (count == 0)
- return (1);
+ return 1;
else if (count > 0)
{
/*
| fp_maskr[5][(r >> 16) & 0xff]
| fp_maskr[6][(r >> 8) & 0xff]
| fp_maskr[7][r & 0xff];
- return (0);
+ return 0;
}
static int
retval = do_des(rawl, rawr, &l_out, &r_out, count);
if (retval)
- return (retval);
+ return retval;
buffer[0] = htonl(l_out);
buffer[1] = htonl(r_out);
/* copy data to avoid assuming output is word-aligned */
memcpy(out, buffer, sizeof(buffer));
- return (retval);
+ return retval;
}
char *
key++;
}
if (des_setkey((char *) keybuf))
- return (NULL);
+ return NULL;
#ifndef DISABLE_XDES
if (*setting == _PASSWORD_EFMT1)
* Encrypt the key with itself.
*/
if (des_cipher((char *) keybuf, (char *) keybuf, 0L, 1))
- return (NULL);
+ return NULL;
/*
* And XOR with the next 8 characters of the key.
*q++ ^= *key++ << 1;
if (des_setkey((char *) keybuf))
- return (NULL);
+ return NULL;
}
StrNCpy(output, setting, 10);
* Do it.
*/
if (do_des(0L, 0L, &r0, &r1, count))
- return (NULL);
+ return NULL;
/*
* Now encode the result...
*p++ = _crypt_a64[l & 0x3f];
*p = 0;
- return (output);
+ return output;
}
tuple = heap_form_tuple(tupleDesc, values, nulls);
result = HeapTupleGetDatum(tuple);
- return (result);
+ return result;
}
/* ------------------------------------------------------
retval = DirectFunctionCall2(seg_union, r1, r2);
*sizep = sizeof(SEG);
- return (retval);
+ return retval;
}
/* ... this is not done yet. */
}
- return (strlen(result));
+ return strlen(result);
}
}
if (!n)
- return (zeroes);
+ return zeroes;
- return (n);
+ return n;
}
newp->splan = NULL;
(*nplans)++;
- return (newp);
+ return newp;
}
AbsoluteTime
currabstime()
{
- return (GetCurrentAbsoluteTime());
+ return GetCurrentAbsoluteTime();
}
*/
newp->splan = NULL;
(*nplans)++;
- return (newp);
+ return newp;
}
SPI_finish();
pfree(command);
- return (proc);
+ return proc;
}
</programlisting>
%%
-open { return(OPEN); }
+open { return OPEN; }
-close { return(XCLOSE); }
+close { return XCLOSE; }
-create { return(XCREATE); }
+create { return XCREATE; }
-OID { return(OBJ_ID); }
-bootstrap { return(XBOOTSTRAP); }
-"shared_relation" { return(XSHARED_RELATION); }
-"without_oids" { return(XWITHOUT_OIDS); }
-"rowtype_oid" { return(XROWTYPE_OID); }
-_null_ { return(NULLVAL); }
+OID { return OBJ_ID; }
+bootstrap { return XBOOTSTRAP; }
+"shared_relation" { return XSHARED_RELATION; }
+"without_oids" { return XWITHOUT_OIDS; }
+"rowtype_oid" { return XROWTYPE_OID; }
+_null_ { return NULLVAL; }
-insert { return(INSERT_TUPLE); }
+insert { return INSERT_TUPLE; }
-"," { return(COMMA); }
-"=" { return(EQUALS); }
-"(" { return(LPAREN); }
-")" { return(RPAREN); }
+"," { return COMMA; }
+"=" { return EQUALS; }
+"(" { return LPAREN; }
+")" { return RPAREN; }
[\n] { yyline++; }
[\t] ;
^\#[^\n]* ; /* drop everything after "#" for comments */
-"declare" { return(XDECLARE); }
-"build" { return(XBUILD); }
-"indices" { return(INDICES); }
-"unique" { return(UNIQUE); }
-"index" { return(INDEX); }
-"on" { return(ON); }
-"using" { return(USING); }
-"toast" { return(XTOAST); }
-"FORCE" { return(XFORCE); }
-"NOT" { return(XNOT); }
-"NULL" { return(XNULL); }
+"declare" { return XDECLARE; }
+"build" { return XBUILD; }
+"indices" { return INDICES; }
+"unique" { return UNIQUE; }
+"index" { return INDEX; }
+"on" { return ON; }
+"using" { return USING; }
+"toast" { return XTOAST; }
+"FORCE" { return XFORCE; }
+"NOT" { return XNOT; }
+"NULL" { return XNULL; }
{arrayid} {
yylval.str = MapArrayTypeName(yytext);
- return(ID);
+ return ID;
}
{id} {
yylval.str = scanstr(yytext);
- return(ID);
+ return ID;
}
{sid} {
yytext[strlen(yytext)-1] = '\0'; /* strip off quotes */
yylval.str = scanstr(yytext+1);
yytext[strlen(yytext)] = '"'; /* restore quotes */
- return(ID);
+ return ID;
}
. {
static int
cmpspell(const void *s1, const void *s2)
{
- return (strcmp((*(SPELL *const *) s1)->word, (*(SPELL *const *) s2)->word));
+ return strcmp((*(SPELL *const *) s1)->word, (*(SPELL *const *) s2)->word);
}
static int
cmpspellaffix(const void *s1, const void *s2)
{
- return (strcmp((*(SPELL *const *) s1)->p.flag,
- (*(SPELL *const *) s2)->p.flag));
+ return strcmp((*(SPELL *const *) s1)->p.flag,
+ (*(SPELL *const *) s2)->p.flag);
}
static int
if (cur == forms)
{
pfree(forms);
- return (NULL);
+ return NULL;
}
- return (forms);
+ return forms;
}
typedef struct SplitVar
switch (af)
{
case PGSQL_AF_INET:
- return (inet_cidr_ntop_ipv4(src, bits, dst, size));
+ return inet_cidr_ntop_ipv4(src, bits, dst, size);
case PGSQL_AF_INET6:
- return (inet_cidr_ntop_ipv6(src, bits, dst, size));
+ return inet_cidr_ntop_ipv6(src, bits, dst, size);
default:
errno = EAFNOSUPPORT;
- return (NULL);
+ return NULL;
}
}
if (bits < 0 || bits > 32)
{
errno = EINVAL;
- return (NULL);
+ return NULL;
}
if (bits == 0)
if (size <= sizeof "/32")
goto emsgsize;
dst += SPRINTF((dst, "/%u", bits));
- return (odst);
+ return odst;
emsgsize:
errno = EMSGSIZE;
- return (NULL);
+ return NULL;
}
/*
if (bits < 0 || bits > 128)
{
errno = EINVAL;
- return (NULL);
+ return NULL;
}
cp = outbuf;
goto emsgsize;
strcpy(dst, outbuf);
- return (dst);
+ return dst;
emsgsize:
errno = EMSGSIZE;
- return (NULL);
+ return NULL;
}
inet_cidr_pton_ipv6(src, dst, size);
default:
errno = EAFNOSUPPORT;
- return (-1);
+ return -1;
}
}
goto emsgsize;
*dst++ = '\0';
}
- return (bits);
+ return bits;
enoent:
errno = ENOENT;
- return (-1);
+ return -1;
emsgsize:
errno = EMSGSIZE;
- return (-1);
+ return -1;
}
/*
enoent:
errno = ENOENT;
- return (-1);
+ return -1;
emsgsize:
errno = EMSGSIZE;
- return (-1);
+ return -1;
}
static int
if (pch != NULL)
{
if (n++ != 0 && val == 0) /* no leading zeros */
- return (0);
+ return 0;
val *= 10;
val += (pch - digits);
if (val > 128) /* range */
- return (0);
+ return 0;
continue;
}
- return (0);
+ return 0;
}
if (n == 0)
- return (0);
+ return 0;
*bitsp = val;
- return (1);
+ return 1;
}
static int
if (pch != NULL)
{
if (n++ != 0 && val == 0) /* no leading zeros */
- return (0);
+ return 0;
val *= 10;
val += (pch - digits);
if (val > 255) /* range */
- return (0);
+ return 0;
continue;
}
if (ch == '.' || ch == '/')
{
if (dst - odst > 3) /* too many octets? */
- return (0);
+ return 0;
*dst++ = val;
if (ch == '/')
- return (getbits(src, bitsp));
+ return getbits(src, bitsp);
val = 0;
n = 0;
continue;
}
- return (0);
+ return 0;
}
if (n == 0)
- return (0);
+ return 0;
if (dst - odst > 3) /* too many octets? */
- return (0);
+ return 0;
*dst++ = val;
- return (1);
+ return 1;
}
static int
*/
memcpy(dst, tmp, NS_IN6ADDRSZ);
- return (bits);
+ return bits;
enoent:
errno = ENOENT;
- return (-1);
+ return -1;
emsgsize:
errno = EMSGSIZE;
- return (-1);
+ return -1;
}
{
StopMiddle = StopLow + (StopHigh - StopLow) / 2;
if (*StopMiddle == val->valcrc)
- return (true);
+ return true;
else if (*StopMiddle < val->valcrc)
StopLow = StopMiddle + 1;
else
StopHigh = StopMiddle;
}
- return (false);
+ return false;
}
static bool
(((($ucs & 0x3ffff) >> 12) | 0x80) << 16) |
(((($ucs & 0x0fc0) >> 6) | 0x80) << 8) | (($ucs & 0x003f) | 0x80);
}
- return ($utf);
+ return $utf;
}
1;
for (i = 0; i < sizeof(b2c3) / (sizeof(unsigned short) * 2); i++)
{
if (b2c3[i][1] == cns)
- return (b2c3[i][0]);
+ return b2c3[i][0];
}
break;
case LC_CNS11643_4:
for (i = 0; i < sizeof(b1c4) / (sizeof(unsigned short) * 2); i++)
{
if (b1c4[i][1] == cns)
- return (b1c4[i][0]);
+ return b1c4[i][0];
}
default:
break;
PGTYPESnumeric_free(a1);
PGTYPESnumeric_free(a2);
- return (i);
+ return i;
}
static int
PGTYPESnumeric_free(a1);
PGTYPESnumeric_free(a2);
- return (i);
+ return i;
}
/* we start with the numeric functions */
int
deccmp(decimal *arg1, decimal *arg2)
{
- return (deccall2(arg1, arg2, PGTYPESnumeric_cmp));
+ return deccall2(arg1, arg2, PGTYPESnumeric_cmp);
}
void
result = PGTYPESnumeric_to_decimal(nres, np);
PGTYPESnumeric_free(nres);
- return (result);
+ return result;
}
int
result = PGTYPESnumeric_to_decimal(nres, np);
PGTYPESnumeric_free(nres);
- return (result);
+ return result;
}
int
result = PGTYPESnumeric_to_decimal(nres, np);
PGTYPESnumeric_free(nres);
- return (result);
+ return result;
}
int
int
rdayofweek(date d)
{
- return (PGTYPESdate_dayofweek(d));
+ return PGTYPESdate_dayofweek(d);
}
/* And the datetime stuff */
int
risnull(int t, char *ptr)
{
- return (ECPGis_noind_null(t, ptr));
+ return ECPGis_noind_null(t, ptr);
}
ret = con;
}
- return (ret);
+ return ret;
}
struct connection *
#endif
}
- return (ret);
+ return ret;
}
static void
PGresult *results;
if (!ecpg_init(con, connection_name, lineno))
- return (false);
+ return false;
ecpg_log("ECPGsetcommit on line %d: action \"%s\"; connection \"%s\"\n", lineno, mode, con->name);
struct connection *con = ecpg_get_connection(connection_name);
if (!ecpg_init(con, connection_name, lineno))
- return (false);
+ return false;
#ifdef ENABLE_THREAD_SAFETY
pthread_setspecific(actual_connection_key, con);
{
ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
- return (false);
+ return false;
}
#ifdef ENABLE_THREAD_SAFETY
#ifdef ENABLE_THREAD_SAFETY
pthread_mutex_unlock(&connections_mutex);
#endif
- return (false);
+ return false;
}
else
ecpg_finish(con);
{
ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
- return (false);
+ return false;
}
/*
* at least one tuple, but let's play it safe.
*/
ecpg_raise(lineno, ECPG_NOT_FOUND, ECPG_SQLSTATE_NO_DATA, NULL);
- return (false);
+ return false;
}
/* We will have to decode the value */
ecpg_raise(lineno, ECPG_MISSING_INDICATOR,
ECPG_SQLSTATE_NULL_VALUE_NO_INDICATOR_PARAMETER,
NULL);
- return (false);
+ return false;
}
}
break;
ecpg_raise(lineno, ECPG_UNSUPPORTED,
ECPG_SQLSTATE_ECPG_INTERNAL_ERROR,
ecpg_type_name(ind_type));
- return (false);
+ return false;
break;
}
if (value_for_indicator == -1)
- return (true);
+ return true;
/* let's check if it really is an array if it should be one */
if (isarray == ECPG_ARRAY_ARRAY)
{
ecpg_raise(lineno, ECPG_DATA_NOT_ARRAY,
ECPG_SQLSTATE_DATATYPE_MISMATCH, NULL);
- return (false);
+ return false;
}
switch (type)
{
ecpg_raise(lineno, ECPG_INT_FORMAT,
ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
pval = scan_length;
{
ecpg_raise(lineno, ECPG_UINT_FORMAT,
ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
pval = scan_length;
if (garbage_left(isarray, scan_length, compat))
{
ecpg_raise(lineno, ECPG_INT_FORMAT, ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
pval = scan_length;
if (garbage_left(isarray, scan_length, compat))
{
ecpg_raise(lineno, ECPG_UINT_FORMAT, ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
pval = scan_length;
{
ecpg_raise(lineno, ECPG_FLOAT_FORMAT,
ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
pval = scan_length;
ecpg_raise(lineno, ECPG_CONVERT_BOOL,
ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
break;
case ECPGt_char:
{
ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
- return (false);
+ return false;
}
}
else
{
ecpg_raise(lineno, ECPG_NUMERIC_FORMAT,
ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
}
else
free(nres);
ecpg_raise(lineno, ECPG_NUMERIC_FORMAT,
ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
}
pval = scan_length;
*/
ires = (interval *) ecpg_alloc(sizeof(interval), lineno);
if (!ires)
- return (false);
+ return false;
ECPGset_noind_null(ECPGt_interval, ires);
}
{
ecpg_raise(lineno, ECPG_INTERVAL_FORMAT,
ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
}
else
free(ires);
ecpg_raise(lineno, ECPG_INTERVAL_FORMAT,
ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
}
pval = scan_length;
{
ecpg_raise(lineno, ECPG_DATE_FORMAT,
ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
}
else
{
ecpg_raise(lineno, ECPG_DATE_FORMAT,
ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
}
{
ecpg_raise(lineno, ECPG_TIMESTAMP_FORMAT,
ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
}
else
{
ecpg_raise(lineno, ECPG_TIMESTAMP_FORMAT,
ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
- return (false);
+ return false;
}
}
ecpg_raise(lineno, ECPG_UNSUPPORTED,
ECPG_SQLSTATE_ECPG_INTERNAL_ERROR,
ecpg_type_name(type));
- return (false);
+ return false;
break;
}
if (ECPG_IS_ARRAY(isarray))
}
} while (*pval != '\0' && !array_boundary(isarray, *pval));
- return (true);
+ return true;
}
break;
default:
ecpg_raise(lineno, ECPG_VAR_NOT_NUMERIC, ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, NULL);
- return (false);
+ return false;
}
- return (true);
+ return true;
}
static bool
break;
default:
ecpg_raise(lineno, ECPG_VAR_NOT_NUMERIC, ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, NULL);
- return (false);
+ return false;
}
return true;
break;
default:
ecpg_raise(lineno, ECPG_VAR_NOT_CHAR, ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, NULL);
- return (false);
+ return false;
}
- return (true);
+ return true;
}
#define RETURN_IF_NO_DATA if (ntuples < 1) \
{ \
va_end(args); \
ecpg_raise(lineno, ECPG_NOT_FOUND, ECPG_SQLSTATE_NO_DATA, NULL); \
- return (false); \
+ return false; \
}
bool
if (!ECPGresult)
{
va_end(args);
- return (false);
+ return false;
}
ntuples = PQntuples(ECPGresult);
{
ecpg_raise(lineno, ECPG_INVALID_DESCRIPTOR_INDEX, ECPG_SQLSTATE_INVALID_DESCRIPTOR_INDEX, NULL);
va_end(args);
- return (false);
+ return false;
}
ecpg_log("ECPGget_desc: reading items for tuple %d\n", index);
if (!get_char_item(lineno, var, vartype, PQfname(ECPGresult, index), varcharsize))
{
va_end(args);
- return (false);
+ return false;
}
ecpg_log("ECPGget_desc: NAME = %s\n", PQfname(ECPGresult, index));
if (!get_int_item(lineno, var, vartype, 1))
{
va_end(args);
- return (false);
+ return false;
}
break;
if (!get_int_item(lineno, var, vartype, 0))
{
va_end(args);
- return (false);
+ return false;
}
break;
if (!get_int_item(lineno, var, vartype, (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff))
{
va_end(args);
- return (false);
+ return false;
}
ecpg_log("ECPGget_desc: SCALE = %d\n", (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff);
if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) >> 16))
{
va_end(args);
- return (false);
+ return false;
}
ecpg_log("ECPGget_desc: PRECISION = %d\n", PQfmod(ECPGresult, index) >> 16);
if (!get_int_item(lineno, var, vartype, PQfsize(ECPGresult, index)))
{
va_end(args);
- return (false);
+ return false;
}
ecpg_log("ECPGget_desc: OCTET_LENGTH = %d\n", PQfsize(ECPGresult, index));
if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) - VARHDRSZ))
{
va_end(args);
- return (false);
+ return false;
}
ecpg_log("ECPGget_desc: LENGTH = %d\n", PQfmod(ECPGresult, index) - VARHDRSZ);
if (!get_int_item(lineno, var, vartype, ecpg_dynamic_type(PQftype(ECPGresult, index))))
{
va_end(args);
- return (false);
+ return false;
}
ecpg_log("ECPGget_desc: TYPE = %d\n", ecpg_dynamic_type(PQftype(ECPGresult, index)));
if (!get_int_item(lineno, var, vartype, ecpg_dynamic_type_DDT(PQftype(ECPGresult, index))))
{
va_end(args);
- return (false);
+ return false;
}
ecpg_log("ECPGget_desc: TYPE = %d\n", ecpg_dynamic_type_DDT(PQftype(ECPGresult, index)));
if (!get_int_item(lineno, var, vartype, PQntuples(ECPGresult)))
{
va_end(args);
- return (false);
+ return false;
}
ecpg_log("ECPGget_desc: CARDINALITY = %d\n", PQntuples(ECPGresult));
if (!get_int_item(lineno, var, vartype, PQgetlength(ECPGresult, act_tuple, index)))
{
va_end(args);
- return (false);
+ return false;
}
var = (char *) var + offset;
ecpg_log("ECPGget_desc: RETURNED[%d] = %d\n", act_tuple, PQgetlength(ECPGresult, act_tuple, index));
snprintf(type_str, sizeof(type_str), "%d", type);
ecpg_raise(lineno, ECPG_UNKNOWN_DESCRIPTOR_ITEM, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, type_str);
va_end(args);
- return (false);
+ return false;
}
type = va_arg(args, enum ECPGdtype);
if (!get_int_item(lineno, data_var.ind_value, data_var.ind_type, -PQgetisnull(ECPGresult, act_tuple, index)))
{
va_end(args);
- return (false);
+ return false;
}
data_var.ind_value = (char *) data_var.ind_value + data_var.ind_offset;
ecpg_log("ECPGget_desc: INDICATOR[%d] = %d\n", act_tuple, -PQgetisnull(ECPGresult, act_tuple, index));
}
sqlca->sqlerrd[2] = ntuples;
va_end(args);
- return (true);
+ return true;
}
#undef RETURN_IF_NO_DATA
{
ecpg_log("ecpg_check_PQresult on line %d: no result - %s", lineno, PQerrorMessage(connection));
ecpg_raise_backend(lineno, NULL, connection, compat);
- return (false);
+ return false;
}
switch (PQresultStatus(results))
{
case PGRES_TUPLES_OK:
- return (true);
+ return true;
break;
case PGRES_EMPTY_QUERY:
/* do nothing */
ecpg_raise(lineno, ECPG_EMPTY, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, NULL);
PQclear(results);
- return (false);
+ return false;
break;
case PGRES_COMMAND_OK:
- return (true);
+ return true;
break;
case PGRES_NONFATAL_ERROR:
case PGRES_FATAL_ERROR:
ecpg_log("ecpg_check_PQresult on line %d: bad response - %s", lineno, PQresultErrorMessage(results));
ecpg_raise_backend(lineno, results, connection, compat);
PQclear(results);
- return (false);
+ return false;
break;
case PGRES_COPY_OUT:
- return (true);
+ return true;
break;
case PGRES_COPY_IN:
ecpg_log("ecpg_check_PQresult on line %d: COPY IN data transfer in progress\n", lineno);
PQendcopy(connection);
PQclear(results);
- return (false);
+ return false;
break;
default:
ecpg_log("ecpg_check_PQresult on line %d: unknown execution status type\n",
lineno);
ecpg_raise_backend(lineno, results, connection, compat);
PQclear(results);
- return (false);
+ return false;
break;
}
}
buffer_len = 2 * length + 1;
res = (char *) ecpg_alloc(buffer_len + 3, lineno);
if (!res)
- return (res);
+ return res;
escaped_len = PQescapeString(res + 1, arg, buffer_len);
if (length == escaped_len)
{
= (struct ECPGtype_information_cache *) ecpg_alloc(sizeof(struct ECPGtype_information_cache), lineno);
if (new_entry == NULL)
- return (false);
+ return false;
new_entry->oid = oid;
new_entry->isarray = isarray;
new_entry->next = *cache;
*cache = new_entry;
- return (true);
+ return true;
}
static enum ARRAY_TYPE
/* populate cache with well known types to speed things up */
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), BOOLOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), BYTEAOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), CHAROID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), NAMEOID, not_an_array_in_ecpg, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), INT8OID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), INT2OID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), INT2VECTOROID, ECPG_ARRAY_VECTOR, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), INT4OID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), REGPROCOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), TEXTOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), OIDOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), TIDOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), XIDOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), CIDOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), OIDVECTOROID, ECPG_ARRAY_VECTOR, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), POINTOID, ECPG_ARRAY_VECTOR, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), LSEGOID, ECPG_ARRAY_VECTOR, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), PATHOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), BOXOID, ECPG_ARRAY_VECTOR, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), POLYGONOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), LINEOID, ECPG_ARRAY_VECTOR, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), FLOAT4OID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), FLOAT8OID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), ABSTIMEOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), RELTIMEOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), TINTERVALOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), UNKNOWNOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), CIRCLEOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), CASHOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), INETOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), CIDROID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), BPCHAROID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), VARCHAROID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), DATEOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), TIMEOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), TIMESTAMPOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), TIMESTAMPTZOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), INTERVALOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), TIMETZOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), ZPBITOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), VARBITOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
if (!ecpg_type_infocache_push(&(stmt->connection->cache_head), NUMERICOID, ECPG_ARRAY_NONE, stmt->lineno))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
}
for (cache_entry = (stmt->connection->cache_head); cache_entry != NULL; cache_entry = cache_entry->next)
array_query = (char *) ecpg_alloc(strlen("select typlen from pg_type where oid= and typelem<>0") + 11, stmt->lineno);
if (array_query == NULL)
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
sprintf(array_query, "select typlen from pg_type where oid=%d and typelem<>0", type);
query = PQexec(stmt->connection->connection, array_query);
ecpg_free(array_query);
if (!ecpg_check_PQresult(query, stmt->lineno, stmt->connection->connection, stmt->compat))
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
else if (PQresultStatus(query) == PGRES_TUPLES_OK)
{
if (PQntuples(query) == 0)
PQclear(query);
}
else
- return (ECPG_ARRAY_ERROR);
+ return ECPG_ARRAY_ERROR;
ecpg_type_infocache_push(&(stmt->connection->cache_head), type, isarray, stmt->lineno);
ecpg_log("ecpg_is_type_an_array on line %d: type (%d); C (%d); array (%s)\n", stmt->lineno, type, var->type, ECPG_IS_ARRAY(isarray) ? "yes" : "no");
{
ecpg_raise(stmt->lineno, ECPG_OUT_OF_MEMORY,
ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
- return (false);
+ return false;
}
var = stmt->outlist;
else if (!INFORMIX_MODE(stmt->compat))
{
ecpg_raise(stmt->lineno, ECPG_TOO_FEW_ARGUMENTS, ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_TARGETS, NULL);
- return (false);
+ return false;
}
}
{
ecpg_raise(lineno, ECPG_INVALID_STMT, ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME, stmt->command);
ecpg_do_epilogue(stmt);
- return (false);
+ return false;
}
}
return NULL;
}
- return (new);
+ return new;
}
char *
return NULL;
}
- return (new);
+ return new;
}
char *
return NULL;
}
- return (new);
+ return new;
}
/* keep a list of memory we allocated for the user */
{
ecpg_raise(lineno, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY,
NULL);
- return (false);
+ return false;
}
ecpg_init_sqlca(sqlca);
{
ecpg_raise(lineno, ECPG_NO_CONN, ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST,
connection_name ? connection_name : ecpg_gettext("NULL"));
- return (false);
+ return false;
}
- return (true);
+ return true;
}
#ifdef ENABLE_THREAD_SAFETY
ecpg_init_sqlca(sqlca);
pthread_setspecific(sqlca_key, sqlca);
}
- return (sqlca);
+ return sqlca;
#else
- return (&sqlca);
+ return &sqlca;
#endif
}
struct connection *con = ecpg_get_connection(connection_name);
if (!ecpg_init(con, connection_name, lineno))
- return (false);
+ return false;
/* are we connected? */
if (con->connection == NULL)
return false;
}
- return (true);
+ return true;
}
PGTransactionStatusType
struct connection *con = ecpg_get_connection(connection_name);
if (!ecpg_init(con, connection_name, lineno))
- return (false);
+ return false;
ecpg_log("ECPGtrans on line %d: action \"%s\"; connection \"%s\"\n", lineno, transaction, con ? con->name : "null");
break;
#endif /* HAVE_LONG_LONG_INT */
case ECPGt_float:
- return (_check(ptr, sizeof(float)));
+ return _check(ptr, sizeof(float));
break;
case ECPGt_double:
- return (_check(ptr, sizeof(double)));
+ return _check(ptr, sizeof(double));
break;
case ECPGt_varchar:
if (*(((struct ECPGgeneric_varchar *) ptr)->arr) == 0x00)
return true;
break;
case ECPGt_interval:
- return (_check(ptr, sizeof(interval)));
+ return _check(ptr, sizeof(interval));
break;
case ECPGt_timestamp:
- return (_check(ptr, sizeof(timestamp)));
+ return _check(ptr, sizeof(timestamp));
break;
default:
break;
if (c >= 128)
return true;
- return (false);
+ return false;
}
static bool
if (entIx >= stmtCacheEntPerBucket)
entNo = 0;
- return (entNo);
+ return entNo;
}
/*
entry = &stmtCacheEntries[entNo];
if (!entry->stmtID[0]) /* return if the entry isn't in use */
- return (0);
+ return 0;
con = ecpg_get_connection(entry->connection);
/* free the 'prepared_statement' list entry */
this = ecpg_find_prepared_statement(entry->stmtID, con, &prev);
if (this && !deallocate_one(lineno, compat, con, prev, this))
- return (-1);
+ return -1;
entry->stmtID[0] = '\0';
entry->ecpgQuery = 0;
}
- return (entNo);
+ return entNo;
}
/*
/* 'entNo' is the entry to use - make sure its free */
if (ecpg_freeStmtCacheEntry(lineno, compat, entNo) < 0)
- return (-1);
+ return -1;
/* add the query to the entry */
entry = &stmtCacheEntries[entNo];
entry->execs = 0;
memcpy(entry->stmtID, stmtID, sizeof(entry->stmtID));
- return (entNo);
+ return entNo;
}
/* handle cache and preparation of statements in auto-prepare mode */
prep = ecpg_find_prepared_statement(stmtID, con, NULL);
/* This prepared name doesn't exist on this connection. */
if (!prep && !prepare_common(lineno, con, stmtID, query))
- return (false);
+ return false;
*name = ecpg_strdup(stmtID, lineno);
}
sprintf(stmtID, "ecpg%d", nextStmtID++);
if (!ECPGprepare(lineno, connection_name, 0, stmtID, query))
- return (false);
+ return false;
if (AddStmtToCache(lineno, stmtID, connection_name, compat, query) < 0)
- return (false);
+ return false;
*name = ecpg_strdup(stmtID, lineno);
}
/* increase usage counter */
stmtCacheEntries[entNo].execs++;
- return (true);
+ return true;
}
if (!new)
errno = ENOMEM;
- return (new);
+ return new;
}
char *
if (!new)
errno = ENOMEM;
- return (new);
+ return new;
}
int
/* Do nothing if we have a default typmod (-1) */
if (typmod < (long) (VARHDRSZ))
- return (0);
+ return 0;
typmod -= VARHDRSZ;
precision = (typmod >> 16) & 0xffff;
var->rscale = scale;
var->dscale = scale;
- return (0);
+ return 0;
}
#endif
dest->weight = 0;
dest->rscale = dest->dscale;
- return (0);
+ return 0;
}
char **ptr = (endptr != NULL) ? endptr : &realptr;
if (!value)
- return (NULL);
+ return NULL;
ret = set_var_from_str(str, ptr, value);
if (ret)
{
PGTYPESnumeric_free(value);
- return (NULL);
+ return NULL;
}
- return (value);
+ return value;
}
char *
/* get_str_from_var may change its argument */
s = get_str_from_var(numcopy, dscale);
PGTYPESnumeric_free(numcopy);
- return (s);
+ return s;
}
/* ----------
if (strlen(str) > MAXDATELEN)
{
errno = PGTYPES_TS_BAD_TIMESTAMP;
- return (noresult);
+ return noresult;
}
if (ParseDateTime(str, lowstr, field, ftype, &nf, ptr) != 0 ||
DecodeDateTime(field, ftype, nf, &dtype, tm, &fsec, 0) != 0)
{
errno = PGTYPES_TS_BAD_TIMESTAMP;
- return (noresult);
+ return noresult;
}
switch (dtype)
if (tm2timestamp(tm, fsec, NULL, &result) != 0)
{
errno = PGTYPES_TS_BAD_TIMESTAMP;
- return (noresult);
+ return noresult;
}
break;
case DTK_INVALID:
errno = PGTYPES_TS_BAD_TIMESTAMP;
- return (noresult);
+ return noresult;
default:
errno = PGTYPES_TS_BAD_TIMESTAMP;
- return (noresult);
+ return noresult;
}
/* AdjustTimestampForTypmod(&result, typmod); */
if (find_my_exec(argv[0], my_exec_path) < 0)
{
fprintf(stderr, _("%s: could not locate my own executable path\n"), argv[0]);
- return (ILLEGAL_OPTION);
+ return ILLEGAL_OPTION;
}
if (argc > 1)
{
fprintf(stderr, _("%s: no input files specified\n"), progname);
fprintf(stderr, _("Try \"%s --help\" for more information.\n"), argv[0]);
- return (ILLEGAL_OPTION);
+ return ILLEGAL_OPTION;
}
else
{
strcat(res_str, str2);
free(str1);
free(str2);
- return(res_str);
+ return res_str;
}
static char *
va_end(args);
- return(res_str);
+ return res_str;
}
static char *
strcat(res_str, str2);
free(str1);
free(str2);
- return(res_str);
+ return res_str;
}
static char *
free(str1);
free(str2);
free(str3);
- return(res_str);
+ return res_str;
}
/* and the rest */
/* removed the trailing " ," */
result[strlen(result)-3] = '\0';
- return(result);
+ return result;
}
static char *
}
<SQL>:{identifier}((("->"|\.){identifier})|(\[{array}\]))* {
base_yylval.str = mm_strdup(yytext+1);
- return(CVARIABLE);
+ return CVARIABLE;
}
<SQL>{identifier} {
const ScanKeyword *keyword;
else
{
base_yylval.str = mm_strdup(yytext);
- return(CPP_LINE);
+ return CPP_LINE;
}
}
<C>{cppinclude_next} {
else
{
base_yylval.str = mm_strdup(yytext);
- return(CPP_LINE);
+ return CPP_LINE;
}
}
<C,SQL>{cppline} {
base_yylval.str = mm_strdup(yytext);
- return(CPP_LINE);
+ return CPP_LINE;
}
<C>{identifier} {
const ScanKeyword *keyword;
}
}
<C>{xcstop} { mmerror(PARSE_ERROR, ET_ERROR, "nested /* ... */ comments"); }
-<C>":" { return(':'); }
-<C>";" { return(';'); }
-<C>"," { return(','); }
-<C>"*" { return('*'); }
-<C>"%" { return('%'); }
-<C>"/" { return('/'); }
-<C>"+" { return('+'); }
-<C>"-" { return('-'); }
-<C>"(" { parenths_open++; return('('); }
-<C>")" { parenths_open--; return(')'); }
+<C>":" { return ':'; }
+<C>";" { return ';'; }
+<C>"," { return ','; }
+<C>"*" { return '*'; }
+<C>"%" { return '%'; }
+<C>"/" { return '/'; }
+<C>"+" { return '+'; }
+<C>"-" { return '-'; }
+<C>"(" { parenths_open++; return '('; }
+<C>")" { parenths_open--; return ')'; }
<C,xskip>{space} { ECHO; }
-<C>\{ { return('{'); }
-<C>\} { return('}'); }
-<C>\[ { return('['); }
-<C>\] { return(']'); }
-<C>\= { return('='); }
-<C>"->" { return(S_MEMBER); }
-<C>">>" { return(S_RSHIFT); }
-<C>"<<" { return(S_LSHIFT); }
-<C>"||" { return(S_OR); }
-<C>"&&" { return(S_AND); }
-<C>"++" { return(S_INC); }
-<C>"--" { return(S_DEC); }
-<C>"==" { return(S_EQUAL); }
-<C>"!=" { return(S_NEQUAL); }
-<C>"+=" { return(S_ADD); }
-<C>"-=" { return(S_SUB); }
-<C>"*=" { return(S_MUL); }
-<C>"/=" { return(S_DIV); }
-<C>"%=" { return(S_MOD); }
-<C>"->*" { return(S_MEMPOINT); }
-<C>".*" { return(S_DOTPOINT); }
+<C>\{ { return '{'; }
+<C>\} { return '}'; }
+<C>\[ { return '['; }
+<C>\] { return ']'; }
+<C>\= { return '='; }
+<C>"->" { return S_MEMBER; }
+<C>">>" { return S_RSHIFT; }
+<C>"<<" { return S_LSHIFT; }
+<C>"||" { return S_OR; }
+<C>"&&" { return S_AND; }
+<C>"++" { return S_INC; }
+<C>"--" { return S_DEC; }
+<C>"==" { return S_EQUAL; }
+<C>"!=" { return S_NEQUAL; }
+<C>"+=" { return S_ADD; }
+<C>"-=" { return S_SUB; }
+<C>"*=" { return S_MUL; }
+<C>"/=" { return S_DIV; }
+<C>"%=" { return S_MOD; }
+<C>"->*" { return S_MEMPOINT; }
+<C>".*" { return S_DOTPOINT; }
<C>{other} { return S_ANYTHING; }
<C>{exec_sql}{define}{space}* { BEGIN(def_ident); }
<C>{informix_special}{define}{space}* {
else
{
yyless(1);
- return (S_ANYTHING);
+ return S_ANYTHING;
}
}
<C>{exec_sql}{undef}{space}* { BEGIN(undef); }
else
{
yyless(1);
- return (S_ANYTHING);
+ return S_ANYTHING;
}
}
<undef>{identifier}{space}*";" {
else
{
yyless(1);
- return (S_ANYTHING);
+ return S_ANYTHING;
}
}
<C,xskip>{exec_sql}{ifdef}{space}* { ifcond = TRUE; BEGIN(xcond); }
else
{
yyless(1);
- return (S_ANYTHING);
+ return S_ANYTHING;
}
}
<C,xskip>{exec_sql}{ifndef}{space}* { ifcond = FALSE; BEGIN(xcond); }
else
{
yyless(1);
- return (S_ANYTHING);
+ return S_ANYTHING;
}
}
<C,xskip>{exec_sql}{elif}{space}* { /* pop stack */
else
{
yyless(1);
- return (S_ANYTHING);
+ return S_ANYTHING;
}
}
else
{
yyless(1);
- return (S_ANYTHING);
+ return S_ANYTHING;
}
}
<C,xskip>{exec_sql}{endif}{space}*";" {
else
{
yyless(1);
- return (S_ANYTHING);
+ return S_ANYTHING;
}
}
rm = rm->next;
}
- return (new);
+ return new;
}
/* The NAME argument is copied. The type argument is preserved as a pointer. */
switch (type)
{
case ECPGt_char:
- return ("ECPGt_char");
+ return "ECPGt_char";
break;
case ECPGt_unsigned_char:
- return ("ECPGt_unsigned_char");
+ return "ECPGt_unsigned_char";
break;
case ECPGt_short:
- return ("ECPGt_short");
+ return "ECPGt_short";
break;
case ECPGt_unsigned_short:
- return ("ECPGt_unsigned_short");
+ return "ECPGt_unsigned_short";
break;
case ECPGt_int:
- return ("ECPGt_int");
+ return "ECPGt_int";
break;
case ECPGt_unsigned_int:
- return ("ECPGt_unsigned_int");
+ return "ECPGt_unsigned_int";
break;
case ECPGt_long:
- return ("ECPGt_long");
+ return "ECPGt_long";
break;
case ECPGt_unsigned_long:
- return ("ECPGt_unsigned_long");
+ return "ECPGt_unsigned_long";
break;
case ECPGt_long_long:
- return ("ECPGt_long_long");
+ return "ECPGt_long_long";
break;
case ECPGt_unsigned_long_long:
- return ("ECPGt_unsigned_long_long");
+ return "ECPGt_unsigned_long_long";
break;
case ECPGt_float:
- return ("ECPGt_float");
+ return "ECPGt_float";
break;
case ECPGt_double:
- return ("ECPGt_double");
+ return "ECPGt_double";
break;
case ECPGt_bool:
- return ("ECPGt_bool");
+ return "ECPGt_bool";
break;
case ECPGt_varchar:
- return ("ECPGt_varchar");
+ return "ECPGt_varchar";
case ECPGt_NO_INDICATOR: /* no indicator */
- return ("ECPGt_NO_INDICATOR");
+ return "ECPGt_NO_INDICATOR";
break;
case ECPGt_char_variable: /* string that should not be quoted */
- return ("ECPGt_char_variable");
+ return "ECPGt_char_variable";
break;
case ECPGt_const: /* constant string quoted */
- return ("ECPGt_const");
+ return "ECPGt_const";
break;
case ECPGt_decimal:
- return ("ECPGt_decimal");
+ return "ECPGt_decimal";
break;
case ECPGt_numeric:
- return ("ECPGt_numeric");
+ return "ECPGt_numeric";
break;
case ECPGt_interval:
- return ("ECPGt_interval");
+ return "ECPGt_interval";
break;
case ECPGt_descriptor:
- return ("ECPGt_descriptor");
+ return "ECPGt_descriptor";
break;
case ECPGt_sqlda:
- return ("ECPGt_sqlda");
+ return "ECPGt_sqlda";
break;
case ECPGt_date:
- return ("ECPGt_date");
+ return "ECPGt_date";
break;
case ECPGt_timestamp:
- return ("ECPGt_timestamp");
+ return "ECPGt_timestamp";
break;
case ECPGt_string:
- return ("ECPGt_string");
+ return "ECPGt_string";
break;
default:
mmerror(PARSE_ERROR, ET_ERROR, "unrecognized variable type code %d", type);
switch (type)
{
case ECPGd_count:
- return ("ECPGd_countr");
+ return "ECPGd_countr";
break;
case ECPGd_data:
- return ("ECPGd_data");
+ return "ECPGd_data";
break;
case ECPGd_di_code:
- return ("ECPGd_di_code");
+ return "ECPGd_di_code";
break;
case ECPGd_di_precision:
- return ("ECPGd_di_precision");
+ return "ECPGd_di_precision";
break;
case ECPGd_indicator:
- return ("ECPGd_indicator");
+ return "ECPGd_indicator";
break;
case ECPGd_key_member:
- return ("ECPGd_key_member");
+ return "ECPGd_key_member";
break;
case ECPGd_length:
- return ("ECPGd_length");
+ return "ECPGd_length";
break;
case ECPGd_name:
- return ("ECPGd_name");
+ return "ECPGd_name";
break;
case ECPGd_nullable:
- return ("ECPGd_nullable");
+ return "ECPGd_nullable";
break;
case ECPGd_octet:
- return ("ECPGd_octet");
+ return "ECPGd_octet";
break;
case ECPGd_precision:
- return ("ECPGd_precision");
+ return "ECPGd_precision";
break;
case ECPGd_ret_length:
- return ("ECPGd_ret_length");
+ return "ECPGd_ret_length";
case ECPGd_ret_octet:
- return ("ECPGd_ret_octet");
+ return "ECPGd_ret_octet";
break;
case ECPGd_scale:
- return ("ECPGd_scale");
+ return "ECPGd_scale";
break;
case ECPGd_type:
- return ("ECPGd_type");
+ return "ECPGd_type";
break;
case ECPGd_cardinality:
- return ("ECPGd_cardinality");
+ return "ECPGd_cardinality";
default:
mmerror(PARSE_ERROR, ET_ERROR, "unrecognized descriptor item code %d", type);
}
p->next = allvariables;
allvariables = p;
- return (p);
+ return p;
}
static struct variable *
switch (members->type->type)
{
case ECPGt_array:
- return (new_variable(name, ECPGmake_array_type(ECPGmake_simple_type(members->type->u.element->type, members->type->u.element->size, members->type->u.element->counter), members->type->size), brace_level));
+ return new_variable(name, ECPGmake_array_type(ECPGmake_simple_type(members->type->u.element->type, members->type->u.element->size, members->type->u.element->counter), members->type->size), brace_level);
case ECPGt_struct:
case ECPGt_union:
- return (new_variable(name, ECPGmake_struct_type(members->type->u.members, members->type->type, members->type->type_name, members->type->struct_sizeof), brace_level));
+ return new_variable(name, ECPGmake_struct_type(members->type->u.members, members->type->type, members->type->type_name, members->type->struct_sizeof), brace_level);
default:
- return (new_variable(name, ECPGmake_simple_type(members->type->type, members->type->size, members->type->counter), brace_level));
+ return new_variable(name, ECPGmake_simple_type(members->type->type, members->type->size, members->type->counter), brace_level);
}
}
else
switch (members->type->u.element->type)
{
case ECPGt_array:
- return (new_variable(name, ECPGmake_array_type(ECPGmake_simple_type(members->type->u.element->u.element->type, members->type->u.element->u.element->size, members->type->u.element->u.element->counter), members->type->u.element->size), brace_level));
+ return new_variable(name, ECPGmake_array_type(ECPGmake_simple_type(members->type->u.element->u.element->type, members->type->u.element->u.element->size, members->type->u.element->u.element->counter), members->type->u.element->size), brace_level);
case ECPGt_struct:
case ECPGt_union:
- return (new_variable(name, ECPGmake_struct_type(members->type->u.element->u.members, members->type->u.element->type, members->type->u.element->type_name, members->type->u.element->struct_sizeof), brace_level));
+ return new_variable(name, ECPGmake_struct_type(members->type->u.element->u.members, members->type->u.element->type, members->type->u.element->type_name, members->type->u.element->struct_sizeof), brace_level);
default:
- return (new_variable(name, ECPGmake_simple_type(members->type->u.element->type, members->type->u.element->size, members->type->u.element->counter), brace_level));
+ return new_variable(name, ECPGmake_simple_type(members->type->u.element->type, members->type->u.element->size, members->type->u.element->counter), brace_level);
}
break;
case '-':
if (members->type->type == ECPGt_array)
- return (find_struct_member(name, ++end, members->type->u.element->u.members, brace_level));
+ return find_struct_member(name, ++end, members->type->u.element->u.members, brace_level);
else
- return (find_struct_member(name, ++end, members->type->u.members, brace_level));
+ return find_struct_member(name, ++end, members->type->u.members, brace_level);
break;
break;
case '.':
if (members->type->type == ECPGt_array)
- return (find_struct_member(name, end, members->type->u.element->u.members, brace_level));
+ return find_struct_member(name, end, members->type->u.element->u.members, brace_level);
else
- return (find_struct_member(name, end, members->type->u.members, brace_level));
+ return find_struct_member(name, end, members->type->u.members, brace_level);
break;
default:
mmfatal(PARSE_ERROR, "incorrectly formed variable \"%s\"", name);
}
}
- return (NULL);
+ return NULL;
}
static struct variable *
return p;
}
- return (NULL);
+ return NULL;
}
/* Note that this function will end the program in case of an unknown */
switch (p->type->u.element->type)
{
case ECPGt_array:
- return (new_variable(name, ECPGmake_array_type(ECPGmake_simple_type(p->type->u.element->u.element->type, p->type->u.element->u.element->size, p->type->u.element->u.element->counter), p->type->u.element->size), p->brace_level));
+ return new_variable(name, ECPGmake_array_type(ECPGmake_simple_type(p->type->u.element->u.element->type, p->type->u.element->u.element->size, p->type->u.element->u.element->counter), p->type->u.element->size), p->brace_level);
case ECPGt_struct:
case ECPGt_union:
- return (new_variable(name, ECPGmake_struct_type(p->type->u.element->u.members, p->type->u.element->type, p->type->u.element->type_name, p->type->u.element->struct_sizeof), p->brace_level));
+ return new_variable(name, ECPGmake_struct_type(p->type->u.element->u.members, p->type->u.element->type, p->type->u.element->type_name, p->type->u.element->struct_sizeof), p->brace_level);
default:
- return (new_variable(name, ECPGmake_simple_type(p->type->u.element->type, p->type->u.element->size, p->type->u.element->counter), p->brace_level));
+ return new_variable(name, ECPGmake_simple_type(p->type->u.element->type, p->type->u.element->size, p->type->u.element->counter), p->brace_level);
}
}
}
if (p == NULL)
mmfatal(PARSE_ERROR, "variable \"%s\" is not declared", name);
- return (p);
+ return p;
}
void
if (!this)
mmfatal(PARSE_ERROR, "unrecognized data type name \"%s\"", name);
- return (this);
+ return this;
}
void
}
free(decarr);
- return (0);
+ return 0;
}
static void
strcpy(msg, "disconnect");
exec sql disconnect;
- return (0);
+ return 0;
}
/* ECPG_INFORMIX_BAD_YEAR */
/* ??? */
- return (0);
+ return 0;
}
static void
fmtlong(-8494493, "abc: ################+-+");
fmtlong(-8494493, "+<<<<,<<<,<<<,<<<");
- return (0);
+ return 0;
}
static void
strcpy(msg, "disconnect");
exec sql disconnect;
- return (0);
+ return 0;
}
exec sql connect to unix:postgresql://localhost/ecpg2_regression user regress_ecpg_user1 identified by "wrongpw";
/* no disconnect necessary */
- return (0);
+ return 0;
}
/* disconnect from "second" */
exec sql disconnect;
- return (0);
+ return 0;
}
* are used in other tests
*/
- return (0);
+ return 0;
}
exec sql disconnect DEFAULT;
- return (0);
+ return 0;
}
/* not connected */
exec sql disconnect nonexistant;
- return (0);
+ return 0;
}
}
free(decarr);
- return (0);
+ return 0;
}
static void
#line 196 "describe.pgc"
- return (0);
+ return 0;
}
/* ECPG_INFORMIX_BAD_YEAR */
/* ??? */
- return (0);
+ return 0;
}
static void
fmtlong(-8494493, "abc: ################+-+");
fmtlong(-8494493, "+<<<<,<<<,<<<,<<<");
- return (0);
+ return 0;
}
static void
#line 247 "sqlda.pgc"
- return (0);
+ return 0;
}
/* no disconnect necessary */
- return (0);
+ return 0;
}
#line 43 "test2.pgc"
- return (0);
+ return 0;
}
* are used in other tests
*/
- return (0);
+ return 0;
}
#line 17 "test4.pgc"
- return (0);
+ return 0;
}
#line 73 "test5.pgc"
- return (0);
+ return 0;
}
#line 366 "dt_test.pgc"
- return (0);
+ return 0;
}
PGTYPESinterval_free(i1);
}
- return (0);
+ return 0;
}
#line 91 "nan_test.pgc"
- return (0);
+ return 0;
}
#line 94 "num_test.pgc"
- return (0);
+ return 0;
}
}
free(numarr);
- return (0);
+ return 0;
}
static void
#line 92 "array_of_struct.pgc"
- return( 0 );
+ return 0;
}
#line 253 "cursor.pgc"
- return (0);
+ return 0;
}
#line 59 "define.pgc"
- return (0);
+ return 0;
}
#line 144 "describe.pgc"
- return (0);
+ return 0;
}
#line 124 "outofscope.pgc"
- return (0);
+ return 0;
}
/* All the memory will anyway be freed at the end */
- return( 0 );
+ return 0;
}
{ ECPGdisconnect(__LINE__, "CURRENT");}
#line 25 "strings.pgc"
- return (0);
+ return 0;
}
#line 98 "variable.pgc"
- return (0);
+ return 0;
}
free(t);
- return (0);
+ return 0;
}
#line 196 "describe.pgc"
- return (0);
+ return 0;
}
#line 110 "execute.pgc"
- return (0);
+ return 0;
}
#line 87 "oldexec.pgc"
- return (0);
+ return 0;
}
#line 247 "sqlda.pgc"
- return (0);
+ return 0;
}
#line 41 "twophase.pgc"
- return (0);
+ return 0;
}
if( threads == NULL )
{
fprintf(stderr, "Cannot alloc memory\n");
- return( 1 );
+ return 1;
}
for( n = 0; n < nthreads; n++ )
{
else
printf("ERROR: Failure - expecting %d rows, got %d.\n", nthreads * iterations, l_rows);
- return( 0 );
+ return 0;
}
void *test_thread(void *arg)
if( sqlca.sqlcode != 0 )
{
printf("%s: ERROR: cannot connect to database!\n", l_connection);
- return( NULL );
+ return NULL;
}
{ ECPGtrans(__LINE__, l_connection, "begin");
#line 126 "thread.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
#line 138 "thread.pgc"
- return( NULL );
+ return NULL;
}
#endif /* ENABLE_THREAD_SAFETY */
if( threads == NULL )
{
fprintf(stderr, "Cannot alloc memory\n");
- return( 1 );
+ return 1;
}
for( n = 0; n < nthreads; n++ )
{
else
printf("ERROR: Failure - expecting %d rows, got %d.\n", nthreads * iterations, l_rows);
- return( 0 );
+ return 0;
}
void *test_thread(void *arg)
if( sqlca.sqlcode != 0 )
{
printf("%s: ERROR: cannot connect to database!\n", l_connection);
- return( NULL );
+ return NULL;
}
{ ECPGtrans(__LINE__, NULL, "begin");
#line 127 "thread_implicit.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
#line 139 "thread_implicit.pgc"
- return( NULL );
+ return NULL;
}
#endif /* ENABLE_THREAD_SAFETY */
exec sql disconnect;
- return (0);
+ return 0;
}
exec sql rollback;
exec sql disconnect;
- return (0);
+ return 0;
}
PGTYPESinterval_free(i1);
}
- return (0);
+ return 0;
}
exec sql rollback;
exec sql disconnect;
- return (0);
+ return 0;
}
exec sql rollback;
exec sql disconnect;
- return (0);
+ return 0;
}
}
free(numarr);
- return (0);
+ return 0;
}
static void
EXEC SQL disconnect all;
- return( 0 );
+ return 0;
}
strcpy(msg, "disconnect");
exec sql disconnect all;
- return (0);
+ return 0;
}
exec sql commit;
exec sql disconnect;
- return (0);
+ return 0;
}
strcpy(msg, "disconnect");
exec sql disconnect;
- return (0);
+ return 0;
}
EXEC SQL disconnect all;
/* All the memory will anyway be freed at the end */
- return( 0 );
+ return 0;
}
printf("%s %s %s %s %s %s\n", s1, s2, s3, s4, s5, s6);
exec sql disconnect;
- return (0);
+ return 0;
}
strcpy(msg, "disconnect");
exec sql disconnect;
- return (0);
+ return 0;
}
free(t);
- return (0);
+ return 0;
}
strcpy(msg, "disconnect");
exec sql disconnect;
- return (0);
+ return 0;
}
exec sql commit;
exec sql disconnect;
- return (0);
+ return 0;
}
exec sql commit;
exec sql disconnect;
- return (0);
+ return 0;
}
strcpy(msg, "disconnect");
exec sql disconnect;
- return (0);
+ return 0;
}
strcpy(msg, "disconnect");
exec sql disconnect current;
- return (0);
+ return 0;
}
if( threads == NULL )
{
fprintf(stderr, "Cannot alloc memory\n");
- return( 1 );
+ return 1;
}
for( n = 0; n < nthreads; n++ )
{
else
printf("ERROR: Failure - expecting %d rows, got %d.\n", nthreads * iterations, l_rows);
- return( 0 );
+ return 0;
}
void *test_thread(void *arg)
if( sqlca.sqlcode != 0 )
{
printf("%s: ERROR: cannot connect to database!\n", l_connection);
- return( NULL );
+ return NULL;
}
EXEC SQL AT :l_connection BEGIN;
/* all done */
EXEC SQL AT :l_connection COMMIT;
EXEC SQL DISCONNECT :l_connection;
- return( NULL );
+ return NULL;
}
#endif /* ENABLE_THREAD_SAFETY */
if( threads == NULL )
{
fprintf(stderr, "Cannot alloc memory\n");
- return( 1 );
+ return 1;
}
for( n = 0; n < nthreads; n++ )
{
else
printf("ERROR: Failure - expecting %d rows, got %d.\n", nthreads * iterations, l_rows);
- return( 0 );
+ return 0;
}
void *test_thread(void *arg)
if( sqlca.sqlcode != 0 )
{
printf("%s: ERROR: cannot connect to database!\n", l_connection);
- return( NULL );
+ return NULL;
}
EXEC SQL BEGIN;
/* all done */
EXEC SQL COMMIT;
EXEC SQL DISCONNECT :l_connection;
- return( NULL );
+ return NULL;
}
#endif /* ENABLE_THREAD_SAFETY */
%%
-permutation { return(PERMUTATION); }
-session { return(SESSION); }
-setup { return(SETUP); }
-step { return(STEP); }
-teardown { return(TEARDOWN); }
+permutation { return PERMUTATION; }
+session { return SESSION; }
+setup { return SETUP; }
+step { return STEP; }
+teardown { return TEARDOWN; }
[\n] { yyline++; }
{comment} { /* ignore */ }
projects / postgresql / commitdiff