/*
* Variables containing simple states.
*/
-int debugging = 0;
+int debugging = 0;
+static int struct_level = 0;
+
+/* temporarily store record members while creating the data structure */
+struct ECPGrecord_member *record_member_list[128] = { NULL };
/*
* Handle the filename and line numbering.
{
struct variable * p, *prev;
- for (p = prev = allvariables; p; p = p->next)
+ for (p = prev = allvariables; p; p = p ? p->next : NULL)
{
if (p->brace_level >= brace_level)
{
else
prev->next = p->next;
+ ECPGfree_type(p->type);
+ free(p->name);
free(p);
p = prev;
}
dump_variables(list->next);
/* Then the current element. */
- ECPGdump_a_type(yyout, list->variable->name, list->variable->type);
+ ECPGdump_a_type(yyout, list->variable->name, list->variable->type, NULL);
/* Then release the list element. */
free(list);
%token <tagname> S_SYMBOL S_LENGTH S_ANYTHING
%token <tagname> S_VARCHAR S_VARCHAR2
-%token <tagname> S_EXTERN S_STATIC
+%token <tagname> S_EXTERN S_STATIC S_AUTO S_CONST S_REGISTER S_STRUCT
%token <tagname> S_UNSIGNED S_SIGNED
%token <tagname> S_LONG S_SHORT S_INT S_CHAR S_FLOAT S_DOUBLE S_BOOL
%token <tagname> '[' ']' ';' ',' '{' '}'
-%type <type> type type_detailed varchar_type simple_type array_type
+%type <type> type type_detailed varchar_type simple_type array_type struct_type
%type <symbolname> symbol
%type <tagname> maybe_storage_clause varchar_tag
%type <type_enum> simple_tag
/* Here is where we can enter support for typedef. */
variable_declaration : type ';' {
- new_variable($<type>1.name, $<type>1.typ);
- free($<type>1.name);
+ /* don't worry about our list when we're working on a struct */
+ if (struct_level == 0)
+ {
+ new_variable($<type>1.name, $<type>1.typ);
+ free($<type>1.name);
+ }
fprintf(yyout, ";");
}
type : maybe_storage_clause type_detailed { $<type>$ = $<type>2; };
type_detailed : varchar_type { $<type>$ = $<type>1; }
| simple_type { $<type>$ = $<type>1; }
- | array_type {$<type>$ = $<type>1; };
+ | array_type {$<type>$ = $<type>1; }
+ | struct_type {$<type>$ = $<type>1; };
varchar_type : varchar_tag symbol index {
fprintf(yyout, "struct varchar_%s { int len; char arr[%d]; } %s", $<symbolname>2, $<indexsize>3, $<symbolname>2);
- $<type>$.name = $<symbolname>2;
- $<type>$.typ = ECPGmake_varchar_type(ECPGt_varchar, $<indexsize>3);
+ if (struct_level == 0)
+ {
+ $<type>$.name = $<symbolname>2;
+ $<type>$.typ = ECPGmake_varchar_type(ECPGt_varchar, $<indexsize>3);
+ }
+ else
+ ECPGmake_record_member($<symbolname>2, ECPGmake_varchar_type(ECPGt_varchar, $<indexsize>3), &(record_member_list[struct_level-1]));
}
varchar_tag : S_VARCHAR { $<tagname>$ = $<tagname>1; }
simple_type : simple_tag symbol {
fprintf(yyout, "%s %s", ECPGtype_name($<type_enum>1), $<symbolname>2);
- $<type>$.name = $<symbolname>2;
- $<type>$.typ = ECPGmake_simple_type($<type_enum>1);
+ if (struct_level == 0)
+ {
+ $<type>$.name = $<symbolname>2;
+ $<type>$.typ = ECPGmake_simple_type($<type_enum>1);
+ }
+ else
+ ECPGmake_record_member($<symbolname>2, ECPGmake_simple_type($<type_enum>1), &(record_member_list[struct_level-1]));
}
array_type : simple_tag symbol index {
fprintf(yyout, "%s %s [%d]", ECPGtype_name($<type_enum>1), $<symbolname>2, $<indexsize>3);
- $<type>$.name = $<symbolname>2;
- $<type>$.typ = ECPGmake_array_type(ECPGmake_simple_type($<type_enum>1), $<indexsize>3);
+ if (struct_level == 0)
+ {
+ $<type>$.name = $<symbolname>2;
+ $<type>$.typ = ECPGmake_array_type(ECPGmake_simple_type($<type_enum>1), $<indexsize>3);
+ }
+ else
+ ECPGmake_record_member($<symbolname>2, ECPGmake_array_type(ECPGmake_simple_type($<type_enum>1), $<indexsize>3), &(record_member_list[struct_level-1]));
+}
+
+s_struct : S_STRUCT symbol {
+ struct_level++;
+ fprintf(yyout, "struct %s {", $<symbolname>2);
+}
+
+struct_type : s_struct '{' variable_declarations '}' symbol {
+ struct_level--;
+ if (struct_level == 0)
+ {
+ $<type>$.name = $<symbolname>5;
+ $<type>$.typ = ECPGmake_record_type(record_member_list[struct_level]);
+ }
+ else
+ ECPGmake_record_member($<symbolname>5, ECPGmake_record_type(record_member_list[struct_level]), &(record_member_list[struct_level-1]));
+ fprintf(yyout, "} %s", $<symbolname>5);
+ record_member_list[struct_level] = NULL;
}
simple_tag : S_CHAR { $<type_enum>$ = ECPGt_char; }
maybe_storage_clause : S_EXTERN { fwrite(yytext, yyleng, 1, yyout); }
| S_STATIC { fwrite(yytext, yyleng, 1, yyout); }
+ | S_CONST { fwrite(yytext, yyleng, 1, yyout); }
+ | S_REGISTER { fwrite(yytext, yyleng, 1, yyout); }
+ | S_AUTO { fwrite(yytext, yyleng, 1, yyout); }
| /* empty */ { };
index : '[' length ']' {
sqlanything : both_anything;
both_anything : S_LENGTH | S_VARCHAR | S_VARCHAR2
- | S_LONG | S_SHORT | S_INT | S_CHAR | S_FLOAT | S_DOUBLE
+ | S_LONG | S_SHORT | S_INT | S_CHAR | S_FLOAT | S_DOUBLE | S_BOOL
| SQL_OPEN | SQL_CONNECT
| SQL_STRING
| SQL_BEGIN | SQL_END
| SQL_DECLARE | SQL_SECTION
| SQL_INCLUDE
| S_SYMBOL
+ | S_STATIC | S_EXTERN | S_AUTO | S_CONST | S_REGISTER | S_STRUCT
| '[' | ']' | ','
| S_ANYTHING;
#include <stdio.h>
#include <string.h>
+#include <stdlib.h>
#include "type.h"
+/* malloc + error check */
+void *mm_alloc(size_t size)
+{
+ void *ptr = malloc(size);
+
+ if (ptr == NULL)
+ {
+ fprintf(stderr, "Out of memory\n");
+ exit(1);
+ }
+
+ return (ptr);
+}
+
/* Constructors
Yes, I mostly write c++-code
- */
+ */
/* The NAME argument is copied. The type argument is preserved as a pointer. */
struct ECPGrecord_member *
-ECPGmake_record_member(char * name, struct ECPGtype * type)
+ECPGmake_record_member(char *name, struct ECPGtype *type, struct ECPGrecord_member **start)
{
- struct ECPGrecord_member * ne =
- (struct ECPGrecord_member *)malloc(sizeof(struct ECPGrecord_member));
+ struct ECPGrecord_member *ptr, *ne =
+ (struct ECPGrecord_member *) mm_alloc(sizeof(struct ECPGrecord_member));
+
+ ne->name = strdup(name);
+ ne->typ = type;
+ ne->next = NULL;
- ne->name = strdup(name);
- ne->typ = type;
+ for (ptr = *start; ptr && ptr->next; ptr = ptr->next);
- return ne;
+ if (ptr)
+ ptr->next=ne;
+ else
+ *start=ne;
+ return ne;
}
struct ECPGtype *
ECPGmake_simple_type(enum ECPGttype typ)
{
- struct ECPGtype * ne = (struct ECPGtype *)malloc(sizeof(struct ECPGtype));
+ struct ECPGtype *ne = (struct ECPGtype *) mm_alloc(sizeof(struct ECPGtype));
- ne->typ = typ;
- ne->size = 0;
- ne->u.element = 0;
+ ne->typ = typ;
+ ne->size = 0;
+ ne->u.element = 0;
- return ne;
+ return ne;
}
struct ECPGtype *
ECPGmake_varchar_type(enum ECPGttype typ, unsigned short siz)
{
- struct ECPGtype * ne = ECPGmake_simple_type(typ);
+ struct ECPGtype *ne = ECPGmake_simple_type(typ);
- ne->size = siz;
+ ne->size = siz;
- return ne;
+ return ne;
}
struct ECPGtype *
-ECPGmake_array_type(struct ECPGtype * typ, unsigned short siz)
+ECPGmake_array_type(struct ECPGtype *typ, unsigned short siz)
{
- struct ECPGtype * ne = ECPGmake_simple_type(ECPGt_array);
+ struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_array);
- ne->size = siz;
- ne->u.element = typ;
+ ne->size = siz;
+ ne->u.element = typ;
- return ne;
+ return ne;
}
struct ECPGtype *
-ECPGmake_record_type(struct ECPGrecord_member * rm[])
+ECPGmake_record_type(struct ECPGrecord_member *rm)
{
- struct ECPGtype * ne = ECPGmake_simple_type(ECPGt_record);
+ struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_record);
- ne->u.members = rm;
+ ne->u.members = rm;
- return ne;
+ return ne;
}
/* Dump a type.
The type is dumped as:
- type-tag <comma> - enum ECPGttype
- reference-to-variable <comma> - void *
- size <comma> - short size of this field (if varchar)
- arrsize <comma> - short number of elements in the arr
- offset <comma> - short offset to the next element
+ type-tag <comma> - enum ECPGttype
+ reference-to-variable <comma> - void *
+ size <comma> - short size of this field (if varchar)
+ arrsize <comma> - short number of elements in the arr
+ offset <comma> - short offset to the next element
Where:
type-tag is one of the simple types or varchar.
reference-to-variable can be a reference to a struct element.
arrsize is the size of the array in case of array fetches. Otherwise 0.
size is the maxsize in case it is a varchar. Otherwise it is the size of
- the variable (required to do array fetches of records).
+ the variable (required to do array fetches of records).
*/
-void ECPGdump_a_simple(FILE * o, const char * name, enum ECPGttype typ,
- short varcharsize,
- unsigned short arrsiz, const char * siz);
-void ECPGdump_a_record(FILE * o, const char * name, unsigned short arrsiz,
- struct ECPGtype * typ, const char * offset);
+void ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
+ short varcharsize,
+ unsigned short arrsiz, const char *siz, const char *prefix);
+void ECPGdump_a_record(FILE *o, const char *name, unsigned short arrsiz,
+ struct ECPGtype *typ, const char *offset, const char *prefix);
void
-ECPGdump_a_type(FILE * o, const char * name, struct ECPGtype * typ)
+ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype *typ, const char *prefix)
{
- if (IS_SIMPLE_TYPE(typ->typ))
- {
- ECPGdump_a_simple(o, name, typ->typ, typ->size, 0, 0);
- }
- else if (typ->typ == ECPGt_array)
- {
- if (IS_SIMPLE_TYPE(typ->u.element->typ))
- ECPGdump_a_simple(o, name, typ->u.element->typ,
- typ->u.element->size, typ->size, 0);
- else if (typ->u.element->typ == ECPGt_array)
- {
- abort(); /* Array of array, */
- }
- else if (typ->u.element->typ == ECPGt_record)
- {
- /* Array of records. */
- ECPGdump_a_record(o, name, typ->size, typ->u.element, 0);
- }
- else
- {
- abort();
- }
- }
- else if (typ->typ == ECPGt_record)
- {
- ECPGdump_a_record(o, name, 0, typ, 0);
- }
- else
- {
- abort();
- }
+ if (IS_SIMPLE_TYPE(typ->typ))
+ {
+ ECPGdump_a_simple(o, name, typ->typ, typ->size, 0, 0, prefix);
+ }
+ else if (typ->typ == ECPGt_array)
+ {
+ if (IS_SIMPLE_TYPE(typ->u.element->typ))
+ ECPGdump_a_simple(o, name, typ->u.element->typ,
+ typ->u.element->size, typ->size, 0, prefix);
+ else if (typ->u.element->typ == ECPGt_array)
+ {
+ abort(); /* Array of array, */
+ }
+ else if (typ->u.element->typ == ECPGt_record)
+ {
+ /* Array of records. */
+ ECPGdump_a_record(o, name, typ->size, typ->u.element, 0, prefix);
+ }
+ else
+ {
+ abort();
+ }
+ }
+ else if (typ->typ == ECPGt_record)
+ {
+ ECPGdump_a_record(o, name, 0, typ, 0, prefix);
+ }
+ else
+ {
+ abort();
+ }
}
/* If siz is NULL, then the offset is 0, if not use siz as a
string, it represents the offset needed if we are in an array of records. */
void
-ECPGdump_a_simple(FILE * o, const char * name, enum ECPGttype typ,
- short varcharsize,
- unsigned short arrsiz,
- const char * siz)
+ECPGdump_a_simple(FILE *o, const char *name, enum ECPGttype typ,
+ short varcharsize,
+ unsigned short arrsiz,
+ const char *siz,
+ const char *prefix)
{
- switch (typ)
- {
- case ECPGt_char:
- fprintf(o, "\n\tECPGt_char,&%s,0,%d,%s, ", name, arrsiz,
- siz == NULL ? "sizeof(char)" : siz);
- break;
- case ECPGt_unsigned_char:
- fprintf(o, "\n\tECPGt_unsigned_char,&%s,0,%d,%s, ", name, arrsiz,
- siz == NULL ? "sizeof(unsigned char)" : siz);
- break;
- case ECPGt_short:
- fprintf(o, "\n\tECPGt_short,&%s,0,%d,%s, ", name, arrsiz,
- siz == NULL ? "sizeof(short)" : siz);
- break;
- case ECPGt_unsigned_short:
- fprintf(o,
- "\n\tECPGt_unsigned_short,&%s,0,%d,%s, ", name, arrsiz,
- siz == NULL ? "sizeof(unsigned short)" : siz);
- break;
- case ECPGt_int:
- fprintf(o, "\n\tECPGt_int,&%s,0,%d,%s, ", name, arrsiz,
- siz == NULL ? "sizeof(int)" : siz);
- break;
- case ECPGt_unsigned_int:
- fprintf(o, "\n\tECPGt_unsigned_int,&%s,0,%d,%s, ", name, arrsiz,
- siz == NULL ? "sizeof(unsigned int)" : siz);
- break;
- case ECPGt_long:
- fprintf(o, "\n\tECPGt_long,&%s,0,%d,%s, ", name, arrsiz,
- siz == NULL ? "sizeof(long)" : siz);
- break;
- case ECPGt_unsigned_long:
- fprintf(o, "\n\tECPGt_unsigned_int,&%s,0,%d,%s, ", name, arrsiz,
- siz == NULL ? "sizeof(unsigned int)" : siz);
- break;
- case ECPGt_float:
- fprintf(o, "\n\tECPGt_float,&%s,0,%d,%s, ", name, arrsiz,
- siz == NULL ? "sizeof(float)" : siz);
- break;
- case ECPGt_double:
- fprintf(o, "\n\tECPGt_double,&%s,0,%d,%s, ", name, arrsiz,
- siz == NULL ? "sizeof(double)" : siz);
- break;
- case ECPGt_bool:
- fprintf(o, "\n\tECPGt_bool,&%s,0,%d,%s, ", name, arrsiz,
- siz == NULL ? "sizeof(bool)" : siz);
- break;
- case ECPGt_varchar:
- case ECPGt_varchar2:
- if (siz == NULL)
- fprintf(o, "\n\tECPGt_varchar,&%s,%d,%d,sizeof(struct varchar_%s), ",
- name,
- varcharsize,
- arrsiz, name);
- else
- fprintf(o, "\n\tECPGt_varchar,&%s,%d,%d,%s, ",
- name,
- varcharsize,
- arrsiz, siz);
- break;
- default:
- abort();
- }
+ switch (typ)
+ {
+ case ECPGt_char:
+ fprintf(o, "\n\tECPGt_char,&%s%s,0,%d,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(char)" : siz);
+ break;
+ case ECPGt_unsigned_char:
+ fprintf(o, "\n\tECPGt_unsigned_char,&%s%s,0,%d,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(unsigned char)" : siz);
+ break;
+ case ECPGt_short:
+ fprintf(o, "\n\tECPGt_short,&%s%s,0,%d,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(short)" : siz);
+ break;
+ case ECPGt_unsigned_short:
+ fprintf(o,
+ "\n\tECPGt_unsigned_short,&%s%s,0,%d,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(unsigned short)" : siz);
+ break;
+ case ECPGt_int:
+ fprintf(o, "\n\tECPGt_int,&%s%s,0,%d,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(int)" : siz);
+ break;
+ case ECPGt_unsigned_int:
+ fprintf(o, "\n\tECPGt_unsigned_int,&%s%s,0,%d,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(unsigned int)" : siz);
+ break;
+ case ECPGt_long:
+ fprintf(o, "\n\tECPGt_long,&%s%s,0,%d,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(long)" : siz);
+ break;
+ case ECPGt_unsigned_long:
+ fprintf(o, "\n\tECPGt_unsigned_int,&%s%s,0,%d,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(unsigned int)" : siz);
+ break;
+ case ECPGt_float:
+ fprintf(o, "\n\tECPGt_float,&%s%s,0,%d,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(float)" : siz);
+ break;
+ case ECPGt_double:
+ fprintf(o, "\n\tECPGt_double,&%s%s,0,%d,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(double)" : siz);
+ break;
+ case ECPGt_bool:
+ fprintf(o, "\n\tECPGt_bool,&%s%s,0,%d,%s, ", prefix ? prefix : "", name, arrsiz,
+ siz == NULL ? "sizeof(bool)" : siz);
+ break;
+ case ECPGt_varchar:
+ case ECPGt_varchar2:
+ if (siz == NULL)
+ fprintf(o, "\n\tECPGt_varchar,&%s%s,%d,%d,sizeof(struct varchar_%s), ",
+ prefix ? prefix : "", name,
+ varcharsize,
+ arrsiz, name);
+ else
+ fprintf(o, "\n\tECPGt_varchar,&%s%s,%d,%d,%s, ",
+ prefix ? prefix : "", name,
+ varcharsize,
+ arrsiz, siz);
+ break;
+ default:
+ abort();
+ }
}
/* Penetrate a record and dump the contents. */
void
-ECPGdump_a_record(FILE * o,
- const char * name, unsigned short arrsiz,
- struct ECPGtype * typ, const char * offsetarg)
+ECPGdump_a_record(FILE *o, const char *name, unsigned short arrsiz, struct ECPGtype *typ, const char *offsetarg, const char *prefix)
{
- /* If offset is NULL, then this is the first recursive level. If not then
- we are in a record in a record and the offset is used as offset.
- */
- struct ECPGrecord_member ** p;
- char obuf[BUFSIZ];
- char buf[BUFSIZ];
- const char * offset;
-
- if (offsetarg == NULL)
- {
- sprintf(obuf, "sizeof(%s)", name);
- offset = obuf;
- }
- else
- {
- offset = offsetarg;
- }
-
- for (p = typ->u.members; *p; p++)
- {
- if (IS_SIMPLE_TYPE((*p)->typ->typ))
- {
- sprintf(buf, "%s.%s", name, (*p)->name);
- ECPGdump_a_simple(o, buf, (*p)->typ->typ, (*p)->typ->size,
- arrsiz, offset);
- }
- else if ((*p)->typ->typ == ECPGt_array)
- {
- int i;
-
- for (i = 0; i < (*p)->typ->size; i++)
- {
- if (IS_SIMPLE_TYPE((*p)->typ->u.element->typ))
- {
- sprintf(buf, "%s.%s[%d]", name, (*p)->name, i);
- ECPGdump_a_simple(o, buf, (*p)->typ->typ, (*p)->typ->size,
- arrsiz, offset);
- }
- else if((*p)->typ->u.element->typ == ECPGt_array)
- {
- /* Array within an array. NOT implemented yet. */
- abort();
- }
- else if ((*p)->typ->u.element->typ == ECPGt_record)
- {
- /* Record within array within record. NOT implemented yet. */
- abort();
- }
- else
- {
- /* Unknown type */
- abort();
- }
- }
- }
- else if ((*p)->typ->typ == ECPGt_record)
- {
- /* Record within a record */
- sprintf(buf, "%s.%s", name, (*p)->name);
- ECPGdump_a_record(o, buf, arrsiz, (*p)->typ, offset);
- }
- else
- {
- /* Unknown type */
- abort();
- }
- }
+ /* If offset is NULL, then this is the first recursive level. If not then
+ we are in a record in a record and the offset is used as offset.
+ */
+ struct ECPGrecord_member *p;
+ char obuf[BUFSIZ];
+ char pbuf[BUFSIZ];
+ const char *offset;
+
+ if (offsetarg == NULL)
+ {
+ sprintf(obuf, "sizeof(%s)", name);
+ offset = obuf;
+ }
+ else
+ {
+ offset = offsetarg;
+ }
+
+ sprintf(pbuf, "%s%s.", prefix ? prefix : "", name);
+ prefix = pbuf;
+
+ for (p = typ->u.members; p; p=p->next)
+ {
+#if 0
+ if (IS_SIMPLE_TYPE(p->typ->typ))
+ {
+ sprintf(buf, "%s.%s", name, p->name);
+ ECPGdump_a_simple(o, buf, p->typ->typ, p->typ->size,
+ arrsiz, offset);
+ }
+ else if (p->typ->typ == ECPGt_array)
+ {
+ int i;
+
+ for (i = 0; i < p->typ->size; i++)
+ {
+ if (IS_SIMPLE_TYPE(p->typ->u.element->typ))
+ {
+ /* sprintf(buf, "%s.%s[%d]", name, p->name, i); */
+ sprintf(buf, "%s.%s", name, p->name);
+ ECPGdump_a_simple(o, buf, p->typ->u.element->typ, p->typ->u.element->size,
+ p->typ->u.element->size, offset);
+ }
+ else if (p->typ->u.element->typ == ECPGt_array)
+ {
+ /* Array within an array. NOT implemented. */
+ abort();
+ }
+ else if (p->typ->u.element->typ == ECPGt_record)
+ {
+ /* Record within array within record. NOT implemented yet. */
+ abort();
+ }
+ else
+ {
+ /* Unknown type */
+ abort();
+ }
+ }
+ }
+ else if (p->typ->typ == ECPGt_record)
+ {
+ /* Record within a record */
+ sprintf(buf, "%s.%s", name, p->name);
+ ECPGdump_a_record(o, buf, arrsiz, p->typ, offset);
+ }
+ else
+ {
+ /* Unknown type */
+ abort();
+ }
+#endif
+ ECPGdump_a_type(o, p->name, p->typ, prefix);
+ }
}
anyway. Lets implement that last! */
void
-ECPGfree_record_member(struct ECPGrecord_member * rm)
+ECPGfree_record_member(struct ECPGrecord_member *rm)
{
+ while (rm)
+ {
+ struct ECPGrecord_member *p = rm;
+
+ rm = rm->next;
+ free(p->name);
+ free(p);
+ }
}
void
-ECPGfree_type(struct ECPGtype * typ)
+ECPGfree_type(struct ECPGtype *typ)
{
+ if (!IS_SIMPLE_TYPE(typ->typ))
+ {
+ if (typ->typ == ECPGt_array)
+ {
+ if (IS_SIMPLE_TYPE(typ->u.element->typ))
+ free(typ->u.element);
+ else if (typ->u.element->typ == ECPGt_array)
+ abort(); /* Array of array, */
+ else if (typ->u.element->typ == ECPGt_record)
+ /* Array of records. */
+ ECPGfree_record_member(typ->u.members);
+ else
+ abort();
+ }
+ else if (typ->typ == ECPGt_record)
+ {
+ ECPGfree_record_member(typ->u.members);
+ }
+ else
+ {
+ abort();
+ }
+ }
+ free(typ);
}
projects / thirdparty / postgresql.git / commitdiff
