mirror of
https://github.com/postgres/postgres.git
synced 2025-05-01 01:04:50 +03:00
540 lines
13 KiB
C
540 lines
13 KiB
C
#include "postgres_fe.h"
|
|
|
|
#include "extern.h"
|
|
|
|
struct variable *allvariables = NULL;
|
|
|
|
struct variable *
|
|
new_variable(const char *name, struct ECPGtype * type, int brace_level)
|
|
{
|
|
struct variable *p = (struct variable *) mm_alloc(sizeof(struct variable));
|
|
|
|
p->name = mm_strdup(name);
|
|
p->type = type;
|
|
p->brace_level = brace_level;
|
|
|
|
p->next = allvariables;
|
|
allvariables = p;
|
|
|
|
return (p);
|
|
}
|
|
|
|
static struct variable *
|
|
find_struct_member(char *name, char *str, struct ECPGstruct_member * members, int brace_level)
|
|
{
|
|
char *next = strpbrk(++str, ".-["),
|
|
*end, c = '\0';
|
|
|
|
if (next != NULL)
|
|
{
|
|
c = *next;
|
|
*next = '\0';
|
|
}
|
|
|
|
for (; members; members = members->next)
|
|
{
|
|
if (strcmp(members->name, str) == 0)
|
|
{
|
|
if (next == NULL)
|
|
{
|
|
/* found the end */
|
|
switch (members->type->type)
|
|
{
|
|
case ECPGt_array:
|
|
return (new_variable(name, ECPGmake_array_type(members->type->u.element, 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->struct_sizeof), brace_level));
|
|
default:
|
|
return (new_variable(name, ECPGmake_simple_type(members->type->type, members->type->size), brace_level));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*next = c;
|
|
if (c == '[')
|
|
{
|
|
int count;
|
|
|
|
/* We don't care about what's inside the array braces
|
|
* so just eat up the character */
|
|
for (count=1, end=next+1; count; end++)
|
|
{
|
|
switch (*end)
|
|
{
|
|
case '[': count++;
|
|
break;
|
|
case ']': count--;
|
|
break;
|
|
default : break;
|
|
}
|
|
}
|
|
}
|
|
else end = next;
|
|
|
|
switch (*end)
|
|
{
|
|
case '\0': /* found the end, but this time it has to be an array element */
|
|
if (members->type->type != ECPGt_array)
|
|
{
|
|
snprintf(errortext, sizeof(errortext), "incorrectly formed variable %s", name);
|
|
mmerror(PARSE_ERROR, ET_FATAL, errortext);
|
|
}
|
|
|
|
switch (members->type->u.element->type)
|
|
{
|
|
case ECPGt_array:
|
|
return (new_variable(name, ECPGmake_array_type(members->type->u.element->u.element, 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->struct_sizeof), brace_level));
|
|
default:
|
|
return (new_variable(name, ECPGmake_simple_type(members->type->u.element->type, members->type->u.element->size), brace_level));
|
|
}
|
|
break;
|
|
case '-': return (find_struct_member(name, end, members->type->u.element->u.members, brace_level));
|
|
break;
|
|
case '.': if (members->type->type != ECPGt_array)
|
|
return (find_struct_member(name, end, members->type->u.element->u.members, brace_level));
|
|
else
|
|
return (find_struct_member(name, next, members->type->u.members, brace_level));
|
|
break;
|
|
default : snprintf(errortext, sizeof(errortext), "incorrectly formed variable %s", name);
|
|
mmerror(PARSE_ERROR, ET_FATAL, errortext);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
static struct variable *
|
|
find_struct(char *name, char *next, char *end)
|
|
{
|
|
struct variable *p;
|
|
char c = *next;
|
|
|
|
/* first get the mother structure entry */
|
|
*next = '\0';
|
|
p = find_variable(name);
|
|
|
|
if (c == '-')
|
|
{
|
|
if (p->type->type != ECPGt_array)
|
|
{
|
|
snprintf(errortext, sizeof(errortext), "variable %s is not a pointer", name);
|
|
mmerror(PARSE_ERROR, ET_FATAL, errortext);
|
|
}
|
|
|
|
if (p->type->u.element->type != ECPGt_struct && p->type->u.element->type != ECPGt_union)
|
|
{
|
|
snprintf(errortext, sizeof(errortext), "variable %s is not a pointer to a structure or a union", name);
|
|
mmerror(PARSE_ERROR, ET_FATAL, errortext);
|
|
}
|
|
|
|
/* restore the name, we will need it later */
|
|
*next = c;
|
|
|
|
return find_struct_member(name, ++end, p->type->u.element->u.members, p->brace_level);
|
|
}
|
|
else
|
|
{
|
|
if (next == end)
|
|
{
|
|
if (p->type->type != ECPGt_struct && p->type->type != ECPGt_union)
|
|
{
|
|
snprintf(errortext, sizeof(errortext), "variable %s is neither a structure nor a union", name);
|
|
mmerror(PARSE_ERROR, ET_FATAL, errortext);
|
|
}
|
|
|
|
/* restore the name, we will need it later */
|
|
*next = c;
|
|
|
|
return find_struct_member(name, end, p->type->u.members, p->brace_level);
|
|
}
|
|
else
|
|
{
|
|
if (p->type->type != ECPGt_array)
|
|
{
|
|
snprintf(errortext, sizeof(errortext), "variable %s is not an array", name);
|
|
mmerror(PARSE_ERROR, ET_FATAL, errortext);
|
|
}
|
|
|
|
if (p->type->u.element->type != ECPGt_struct && p->type->u.element->type != ECPGt_union)
|
|
{
|
|
snprintf(errortext, sizeof(errortext), "variable %s is not a pointer to a structure or a union", name);
|
|
mmerror(PARSE_ERROR, ET_FATAL, errortext);
|
|
}
|
|
|
|
/* restore the name, we will need it later */
|
|
*next = c;
|
|
|
|
return find_struct_member(name, end, p->type->u.element->u.members, p->brace_level);
|
|
}
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
/* Note that this function will end the program in case of an unknown */
|
|
/* variable */
|
|
struct variable *
|
|
find_variable(char *name)
|
|
{
|
|
char *next, *end;
|
|
struct variable *p;
|
|
int count;
|
|
|
|
next = strpbrk(name, ".[-");
|
|
if (next)
|
|
{
|
|
if (*next == '[')
|
|
{
|
|
/* We don't care about what's inside the array braces
|
|
* so just eat up the character */
|
|
for (count=1, end=next+1; count; end++)
|
|
{
|
|
switch (*end)
|
|
{
|
|
case '[': count++;
|
|
break;
|
|
case ']': count--;
|
|
break;
|
|
default : break;
|
|
}
|
|
}
|
|
if (*end == '.') p = find_struct(name, next, end);
|
|
else
|
|
{
|
|
char c = *next;
|
|
|
|
*next = '\0';
|
|
p = find_simple(name);
|
|
*next = c;
|
|
switch (p->type->u.element->type)
|
|
{
|
|
case ECPGt_array:
|
|
return (new_variable(name, ECPGmake_array_type(p->type->u.element->u.element, 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->struct_sizeof), p->brace_level));
|
|
default:
|
|
return (new_variable(name, ECPGmake_simple_type(p->type->u.element->type, p->type->u.element->size), p->brace_level));
|
|
}
|
|
}
|
|
}
|
|
else p = find_struct(name, next, next);
|
|
}
|
|
else p = find_simple(name);
|
|
|
|
if (p == NULL)
|
|
{
|
|
snprintf(errortext, sizeof(errortext), "The variable %s is not declared", name);
|
|
mmerror(PARSE_ERROR, ET_FATAL, errortext);
|
|
}
|
|
|
|
return (p);
|
|
}
|
|
|
|
void
|
|
remove_variables(int brace_level)
|
|
{
|
|
struct variable *p,
|
|
*prev;
|
|
|
|
for (p = prev = allvariables; p; p = p ? p->next : NULL)
|
|
{
|
|
if (p->brace_level >= brace_level)
|
|
{
|
|
/* is it still referenced by a cursor? */
|
|
struct cursor *ptr;
|
|
|
|
for (ptr = cur; ptr != NULL; ptr = ptr->next)
|
|
{
|
|
struct arguments *varptr, *prevvar;
|
|
|
|
for (varptr = prevvar = ptr->argsinsert; varptr != NULL; varptr = varptr->next)
|
|
{
|
|
if (p == varptr->variable)
|
|
{
|
|
/* remove from list */
|
|
if (varptr == ptr->argsinsert)
|
|
ptr->argsinsert = varptr->next;
|
|
else
|
|
prevvar->next = varptr->next;
|
|
}
|
|
}
|
|
for (varptr = ptr->argsresult; varptr != NULL; varptr = varptr->next)
|
|
{
|
|
if (p == varptr->variable)
|
|
{
|
|
/* remove from list */
|
|
if (varptr == ptr->argsresult)
|
|
ptr->argsresult = varptr->next;
|
|
else
|
|
prevvar->next = varptr->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
else
|
|
prev = p;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Here are the variables that need to be handled on every request.
|
|
* These are of two kinds: input and output.
|
|
* I will make two lists for them.
|
|
*/
|
|
|
|
struct arguments *argsinsert = NULL;
|
|
struct arguments *argsresult = NULL;
|
|
|
|
void
|
|
reset_variables(void)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/* 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));
|
|
|
|
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.
|
|
This is a recursive function that works from the end of the list and
|
|
deletes the list as we go on.
|
|
*/
|
|
void
|
|
dump_variables(struct arguments * list, int mode)
|
|
{
|
|
if (list == NULL)
|
|
return;
|
|
|
|
/*
|
|
* The list is build up from the beginning so lets first dump the end
|
|
* of the list:
|
|
*/
|
|
|
|
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, 0, NULL, NULL);
|
|
|
|
/* Then release the list element. */
|
|
if (mode != 0)
|
|
free(list);
|
|
}
|
|
|
|
void
|
|
check_indicator(struct ECPGtype * var)
|
|
{
|
|
/* make sure this is a valid indicator variable */
|
|
switch (var->type)
|
|
{
|
|
struct ECPGstruct_member *p;
|
|
|
|
case ECPGt_short:
|
|
case ECPGt_int:
|
|
case ECPGt_long:
|
|
case ECPGt_long_long:
|
|
case ECPGt_unsigned_short:
|
|
case ECPGt_unsigned_int:
|
|
case ECPGt_unsigned_long:
|
|
case ECPGt_unsigned_long_long:
|
|
break;
|
|
|
|
case ECPGt_struct:
|
|
case ECPGt_union:
|
|
for (p = var->u.members; p; p = p->next)
|
|
check_indicator(p->type);
|
|
break;
|
|
|
|
case ECPGt_array:
|
|
check_indicator(var->u.element);
|
|
break;
|
|
default:
|
|
mmerror(PARSE_ERROR, ET_ERROR, "indicator variable must be integer type");
|
|
break;
|
|
}
|
|
}
|
|
|
|
struct typedefs *
|
|
get_typedef(char *name)
|
|
{
|
|
struct typedefs *this;
|
|
|
|
for (this = types; this && strcmp(this->name, name); this = this->next);
|
|
if (!this)
|
|
{
|
|
snprintf(errortext, sizeof(errortext), "invalid datatype '%s'", name);
|
|
mmerror(PARSE_ERROR, ET_FATAL, errortext);
|
|
}
|
|
|
|
return (this);
|
|
}
|
|
|
|
void
|
|
adjust_array(enum ECPGttype type_enum, char **dimension, char **length, char *type_dimension, char *type_index, int pointer_len)
|
|
{
|
|
if (atoi(type_index) >= 0)
|
|
{
|
|
if (atoi(*length) >= 0)
|
|
mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support");
|
|
|
|
*length = type_index;
|
|
}
|
|
|
|
if (atoi(type_dimension) >= 0)
|
|
{
|
|
if (atoi(*dimension) >= 0 && atoi(*length) >= 0)
|
|
mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support");
|
|
|
|
if (atoi(*dimension) >= 0)
|
|
*length = *dimension;
|
|
|
|
*dimension = type_dimension;
|
|
}
|
|
|
|
if (pointer_len > 2)
|
|
{
|
|
snprintf(errortext, sizeof(errortext), "No multilevel (more than 2) pointer supported %d", pointer_len);
|
|
mmerror(PARSE_ERROR, ET_FATAL, errortext);
|
|
/* mmerror(PARSE_ERROR, ET_FATAL, "No multilevel (more than 2) pointer supported %d",pointer_len);*/
|
|
}
|
|
|
|
if (pointer_len > 1 && type_enum != ECPGt_char && type_enum != ECPGt_unsigned_char)
|
|
mmerror(PARSE_ERROR, ET_FATAL, "No pointer to pointer supported for this type");
|
|
|
|
if (pointer_len > 1 && (atoi(*length) >= 0 || atoi(*dimension) >= 0))
|
|
mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support");
|
|
|
|
if (atoi(*length) >= 0 && atoi(*dimension) >= 0 && pointer_len)
|
|
mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support");
|
|
|
|
switch (type_enum)
|
|
{
|
|
case ECPGt_struct:
|
|
case ECPGt_union:
|
|
/* pointer has to get dimension 0 */
|
|
if (pointer_len)
|
|
{
|
|
*length = *dimension;
|
|
*dimension = make_str("0");
|
|
}
|
|
|
|
if (atoi(*length) >= 0)
|
|
mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support for structures");
|
|
|
|
break;
|
|
case ECPGt_varchar:
|
|
/* pointer has to get dimension 0 */
|
|
if (pointer_len)
|
|
*dimension = make_str("0");
|
|
|
|
/* one index is the string length */
|
|
if (atoi(*length) < 0)
|
|
{
|
|
*length = *dimension;
|
|
*dimension = make_str("-1");
|
|
}
|
|
|
|
break;
|
|
case ECPGt_char:
|
|
case ECPGt_unsigned_char:
|
|
/* char ** */
|
|
if (pointer_len == 2)
|
|
{
|
|
*length = *dimension = make_str("0");
|
|
break;
|
|
}
|
|
|
|
/* pointer has to get length 0 */
|
|
if (pointer_len == 1)
|
|
*length = make_str("0");
|
|
|
|
/* one index is the string length */
|
|
if (atoi(*length) < 0)
|
|
{
|
|
/* make sure we return length = -1 for arrays without given bounds */
|
|
if (atoi(*dimension) < 0)
|
|
*length = make_str("1");
|
|
else if (atoi(*dimension) == 0)
|
|
*length = make_str("-1");
|
|
else
|
|
*length = *dimension;
|
|
|
|
*dimension = make_str("-1");
|
|
}
|
|
break;
|
|
default:
|
|
/* a pointer has dimension = 0 */
|
|
if (pointer_len)
|
|
{
|
|
*length = *dimension;
|
|
*dimension = make_str("0");
|
|
}
|
|
|
|
if (atoi(*length) >= 0)
|
|
mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support for simple data types");
|
|
|
|
break;
|
|
}
|
|
}
|