type.c File Reference

#include "postgres_fe.h"
#include "preproc_extern.h"

Include dependency graph for type.c:

Go to the source code of this file.

Macros
#define	indicator_set   ind_type != NULL && ind_type->type != ECPGt_NO_INDICATOR

Functions
struct ECPGstruct_member *	ECPGstruct_member_dup (struct ECPGstruct_member *rm)
void	ECPGmake_struct_member (const char *name, struct ECPGtype *type, struct ECPGstruct_member **start)
struct ECPGtype *	ECPGmake_simple_type (enum ECPGttype type, const char *size, int counter)
struct ECPGtype *	ECPGmake_array_type (struct ECPGtype *type, const char *size)
struct ECPGtype *	ECPGmake_struct_type (struct ECPGstruct_member *rm, enum ECPGttype type, const char *type_name, const char *struct_sizeof)
static const char *	get_type (enum ECPGttype type)
static void	ECPGdump_a_simple (FILE *o, const char *name, enum ECPGttype type, char *varcharsize, char *arrsize, const char *size, const char *prefix, int counter)
static void	ECPGdump_a_struct (FILE *o, const char *name, const char *ind_name, char *arrsize, struct ECPGtype *type, struct ECPGtype *ind_type, const char *prefix, const char *ind_prefix)
void	ECPGdump_a_type (FILE *o, const char *name, struct ECPGtype *type, const int brace_level, const char *ind_name, struct ECPGtype *ind_type, const int ind_brace_level, const char *prefix, const char *ind_prefix, char *arr_str_size, const char *struct_sizeof, const char *ind_struct_sizeof)
void	ECPGfree_struct_member (struct ECPGstruct_member *rm)
void	ECPGfree_type (struct ECPGtype *type)
const char *	get_dtype (enum ECPGdtype type)

Variables
static struct ECPGstruct_member	struct_no_indicator = {"no_indicator", &ecpg_no_indicator, NULL}

Macro Definition Documentation

indicator_set

#define indicator_set   ind_type != NULL && ind_type->type != ECPGt_NO_INDICATOR

Definition at line 7 of file type.c.

Function Documentation

ECPGdump_a_simple()

static void ECPGdump_a_simple ( FILE *  o, const char *  name, enum ECPGttype  type, char *  varcharsize, char *  arrsize, const char *  size, const char *  prefix, int  counter  )

static

Definition at line 391 of file type.c.

{
    if (type == ECPGt_NO_INDICATOR)
        fprintf(o, "\n\tECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ");
    else if (type == ECPGt_descriptor)
        /* remember that name here already contains quotes (if needed) */
        fprintf(o, "\n\tECPGt_descriptor, %s, 1L, 1L, 1L, ", name);
    else if (type == ECPGt_sqlda)
        fprintf(o, "\n\tECPGt_sqlda, &%s, 0L, 0L, 0L, ", name);
    else
    {
        char       *variable = (char *) mm_alloc(strlen(name) + ((prefix == NULL) ? 0 : strlen(prefix)) + 4);
        char       *offset = (char *) mm_alloc(strlen(name) + strlen("sizeof(struct varchar_)") + 1 + strlen(varcharsize) + sizeof(int) * CHAR_BIT * 10 / 3);
        char       *struct_name;
 
        switch (type)
        {
                /*
                 * we have to use the & operator except for arrays and
                 * pointers
                 */
 
            case ECPGt_varchar:
            case ECPGt_bytea:
 
                /*
                 * we have to use the pointer except for arrays with given
                 * bounds
                 */
                if (((atoi(arrsize) > 0) ||
                     (atoi(arrsize) == 0 && strcmp(arrsize, "0") != 0)) &&
                    size == NULL)
                    sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
                else
                    sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
 
                /*
                 * If we created a varchar structure automatically, counter is
                 * greater than 0.
                 */
                if (type == ECPGt_varchar)
                    struct_name = "struct varchar";
                else
                    struct_name = "struct bytea";
 
                if (counter)
                    sprintf(offset, "sizeof(%s_%d)", struct_name, counter);
                else
                    sprintf(offset, "sizeof(%s)", struct_name);
                break;
            case ECPGt_char:
            case ECPGt_unsigned_char:
            case ECPGt_char_variable:
            case ECPGt_string:
                {
                    char       *sizeof_name = "char";
 
                    /*
                     * we have to use the pointer except for arrays with given
                     * bounds, ecpglib will distinguish between * and []
                     */
                    if ((atoi(varcharsize) > 1 ||
                         (atoi(arrsize) > 0) ||
                         (atoi(varcharsize) == 0 && strcmp(varcharsize, "0") != 0) ||
                         (atoi(arrsize) == 0 && strcmp(arrsize, "0") != 0))
                        && size == NULL)
                    {
                        sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
                        if ((type == ECPGt_char || type == ECPGt_unsigned_char) &&
                            strcmp(varcharsize, "0") == 0)
                        {
                            /*
                             * If this is an array of char *, the offset would
                             * be sizeof(char *) and not sizeof(char).
                             */
                            sizeof_name = "char *";
                        }
                    }
                    else
                        sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
 
                    sprintf(offset, "(%s)*sizeof(%s)", strcmp(varcharsize, "0") == 0 ? "1" : varcharsize, sizeof_name);
                    break;
                }
            case ECPGt_numeric:
 
                /*
                 * we have to use a pointer here
                 */
                sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
                sprintf(offset, "sizeof(numeric)");
                break;
            case ECPGt_interval:
 
                /*
                 * we have to use a pointer here
                 */
                sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
                sprintf(offset, "sizeof(interval)");
                break;
            case ECPGt_date:
 
                /*
                 * we have to use a pointer and translate the variable type
                 */
                sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
                sprintf(offset, "sizeof(date)");
                break;
            case ECPGt_timestamp:
 
                /*
                 * we have to use a pointer and translate the variable type
                 */
                sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
                sprintf(offset, "sizeof(timestamp)");
                break;
            case ECPGt_const:
 
                /*
                 * just dump the const as string
                 */
                sprintf(variable, "\"%s\"", name);
                sprintf(offset, "strlen(\"%s\")", name);
                break;
            default:
 
                /*
                 * we have to use the pointer except for arrays with given
                 * bounds
                 */
                if (((atoi(arrsize) > 0) ||
                     (atoi(arrsize) == 0 && strcmp(arrsize, "0") != 0)) &&
                    size == NULL)
                    sprintf(variable, "(%s%s)", prefix ? prefix : "", name);
                else
                    sprintf(variable, "&(%s%s)", prefix ? prefix : "", name);
 
                sprintf(offset, "sizeof(%s)", ecpg_type_name(type));
                break;
        }
 
        /*
         * Array size would be -1 for addresses of members within structure,
         * when pointer to structure is being dumped.
         */
        if (atoi(arrsize) < 0 && !size)
            strcpy(arrsize, "1");
 
        /*
         * If size i.e. the size of structure of which this variable is part
         * of, that gives the offset to the next element, if required
         */
        if (size == NULL || strlen(size) == 0)
            fprintf(o, "\n\t%s,%s,(long)%s,(long)%s,%s, ", get_type(type), variable, varcharsize, arrsize, offset);
        else
            fprintf(o, "\n\t%s,%s,(long)%s,(long)%s,%s, ", get_type(type), variable, varcharsize, arrsize, size);
 
        free(variable);
        free(offset);
    }
}

References variable::arrsize, ecpg_type_name(), ECPGt_bytea, ECPGt_char, ECPGt_char_variable, ECPGt_const, ECPGt_date, ECPGt_descriptor, ECPGt_interval, ECPGt_NO_INDICATOR, ECPGt_numeric, ECPGt_sqlda, ECPGt_string, ECPGt_timestamp, ECPGt_unsigned_char, ECPGt_varchar, fb(), fprintf, free, get_type(), mm_alloc(), name, variable::offset, sprintf, type, and variable::varcharsize.

Referenced by ECPGdump_a_type().

ECPGdump_a_struct()

static void ECPGdump_a_struct ( FILE *  o, const char *  name, const char *  ind_name, char *  arrsize, struct ECPGtype *  type, struct ECPGtype *  ind_type, const char *  prefix, const char *  ind_prefix  )

static

Definition at line 561 of file type.c.

{
    /*
     * If offset is NULL, then this is the first recursive level. If not then
     * we are in a struct and the offset is used as offset.
     */
    struct ECPGstruct_member *p,
               *ind_p = NULL;
    char       *pbuf = (char *) mm_alloc(strlen(name) + ((prefix == NULL) ? 0 : strlen(prefix)) + 3);
    char       *ind_pbuf = (char *) mm_alloc(strlen(ind_name) + ((ind_prefix == NULL) ? 0 : strlen(ind_prefix)) + 3);
 
    if (atoi(arrsize) == 1)
        sprintf(pbuf, "%s%s.", prefix ? prefix : "", name);
    else
        sprintf(pbuf, "%s%s->", prefix ? prefix : "", name);
 
    prefix = pbuf;
 
    if (ind_type == &ecpg_no_indicator)
        ind_p = &struct_no_indicator;
    else if (ind_type != NULL)
    {
        if (atoi(arrsize) == 1)
            sprintf(ind_pbuf, "%s%s.", ind_prefix ? ind_prefix : "", ind_name);
        else
            sprintf(ind_pbuf, "%s%s->", ind_prefix ? ind_prefix : "", ind_name);
 
        ind_prefix = ind_pbuf;
        ind_p = ind_type->u.members;
    }
 
    for (p = type->u.members; p; p = p->next)
    {
        ECPGdump_a_type(o, p->name, p->type, -1,
                        (ind_p != NULL) ? ind_p->name : NULL,
                        (ind_p != NULL) ? ind_p->type : NULL,
                        -1,
                        prefix, ind_prefix, arrsize, type->struct_sizeof,
                        (ind_p != NULL) ? ind_type->struct_sizeof : NULL);
        if (ind_p != NULL && ind_p != &struct_no_indicator)
        {
            ind_p = ind_p->next;
            if (ind_p == NULL && p->next != NULL)
            {
                mmerror(PARSE_ERROR, ET_WARNING, "indicator struct \"%s\" has too few members", ind_name);
                ind_p = &struct_no_indicator;
            }
        }
    }
 
    if (ind_type != NULL && ind_p != NULL && ind_p != &struct_no_indicator)
    {
        mmerror(PARSE_ERROR, ET_WARNING, "indicator struct \"%s\" has too many members", ind_name);
    }
 
    free(pbuf);
    free(ind_pbuf);
}

References ecpg_no_indicator, ECPGdump_a_type(), ET_WARNING, fb(), free, ECPGtype::members, mm_alloc(), mmerror(), name, ECPGstruct_member::name, ECPGstruct_member::next, PARSE_ERROR, sprintf, struct_no_indicator, ECPGtype::struct_sizeof, type, ECPGstruct_member::type, and ECPGtype::u.

Referenced by ECPGdump_a_type().

ECPGdump_a_type()

void ECPGdump_a_type	(	FILE *	o,
		const char *	name,
		struct ECPGtype *	type,
		const int	brace_level,
		const char *	ind_name,
		struct ECPGtype *	ind_type,
		const int	ind_brace_level,
		const char *	prefix,
		const char *	ind_prefix,
		char *	arr_str_size,
		const char *	struct_sizeof,
		const char *	ind_struct_sizeof
	)

Definition at line 219 of file type.c.

{
    struct variable *var;
 
    if (type->type != ECPGt_descriptor && type->type != ECPGt_sqlda &&
        type->type != ECPGt_char_variable && type->type != ECPGt_const &&
        brace_level >= 0)
    {
        char       *str;
 
        str = mm_strdup(name);
        var = find_variable(str);
        free(str);
 
        if ((var->type->type != type->type) ||
            (var->type->type_name && !type->type_name) ||
            (!var->type->type_name && type->type_name) ||
            (var->type->type_name && type->type_name && strcmp(var->type->type_name, type->type_name) != 0))
            mmerror(PARSE_ERROR, ET_ERROR, "variable \"%s\" is hidden by a local variable of a different type", name);
        else if (var->brace_level != brace_level)
            mmerror(PARSE_ERROR, ET_WARNING, "variable \"%s\" is hidden by a local variable", name);
 
        if (ind_name && ind_type && ind_type->type != ECPGt_NO_INDICATOR && ind_brace_level >= 0)
        {
            str = mm_strdup(ind_name);
            var = find_variable(str);
            free(str);
 
            if ((var->type->type != ind_type->type) ||
                (var->type->type_name && !ind_type->type_name) ||
                (!var->type->type_name && ind_type->type_name) ||
                (var->type->type_name && ind_type->type_name && strcmp(var->type->type_name, ind_type->type_name) != 0))
                mmerror(PARSE_ERROR, ET_ERROR, "indicator variable \"%s\" is hidden by a local variable of a different type", ind_name);
            else if (var->brace_level != ind_brace_level)
                mmerror(PARSE_ERROR, ET_WARNING, "indicator variable \"%s\" is hidden by a local variable", ind_name);
        }
    }
 
    switch (type->type)
    {
        case ECPGt_array:
            if (indicator_set && ind_type->type != ECPGt_array)
                mmfatal(INDICATOR_NOT_ARRAY, "indicator for array/pointer has to be array/pointer");
            switch (type->u.element->type)
            {
                case ECPGt_array:
                    mmerror(PARSE_ERROR, ET_ERROR, "nested arrays are not supported (except strings)"); /* array of array */
                    break;
                case ECPGt_struct:
                case ECPGt_union:
                    ECPGdump_a_struct(o, name,
                                      ind_name,
                                      type->size,
                                      type->u.element,
                                      (ind_type == NULL) ? NULL : ((ind_type->type == ECPGt_NO_INDICATOR) ? ind_type : ind_type->u.element),
                                      prefix, ind_prefix);
                    break;
                default:
                    if (!IS_SIMPLE_TYPE(type->u.element->type))
                        base_yyerror("internal error: unknown datatype, please report this to <" PACKAGE_BUGREPORT ">");
 
                    ECPGdump_a_simple(o, name,
                                      type->u.element->type,
                                      type->u.element->size, type->size, struct_sizeof ? struct_sizeof : NULL,
                                      prefix, type->u.element->counter);
 
                    if (ind_type != NULL)
                    {
                        if (ind_type->type == ECPGt_NO_INDICATOR)
                        {
                            char       *str_neg_one = mm_strdup("-1");
 
                            ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, str_neg_one, NULL, ind_prefix, 0);
                            free(str_neg_one);
                        }
                        else
                        {
                            ECPGdump_a_simple(o, ind_name, ind_type->u.element->type,
                                              ind_type->u.element->size, ind_type->size, NULL, ind_prefix, 0);
                        }
                    }
            }
            break;
        case ECPGt_struct:
            {
                char       *str_one = mm_strdup("1");
 
                if (indicator_set && ind_type->type != ECPGt_struct)
                    mmfatal(INDICATOR_NOT_STRUCT, "indicator for struct has to be a struct");
 
                ECPGdump_a_struct(o, name, ind_name, str_one, type, ind_type, prefix, ind_prefix);
                free(str_one);
            }
            break;
        case ECPGt_union:       /* cannot dump a complete union */
            base_yyerror("type of union has to be specified");
            break;
        case ECPGt_char_variable:
            {
                /*
                 * Allocate for each, as there are code-paths where the values
                 * get stomped on.
                 */
                char       *str_varchar_one = mm_strdup("1");
                char       *str_arr_one = mm_strdup("1");
                char       *str_neg_one = mm_strdup("-1");
 
                if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
                    mmfatal(INDICATOR_NOT_SIMPLE, "indicator for simple data type has to be simple");
 
                ECPGdump_a_simple(o, name, type->type, str_varchar_one, (arr_str_size && strcmp(arr_str_size, "0") != 0) ? arr_str_size : str_arr_one, struct_sizeof, prefix, 0);
                if (ind_type != NULL)
                    ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, (arr_str_size && strcmp(arr_str_size, "0") != 0) ? arr_str_size : str_neg_one, ind_struct_sizeof, ind_prefix, 0);
 
                free(str_varchar_one);
                free(str_arr_one);
                free(str_neg_one);
            }
            break;
        case ECPGt_descriptor:
            {
                /*
                 * Allocate for each, as there are code-paths where the values
                 * get stomped on.
                 */
                char       *str_neg_one = mm_strdup("-1");
                char       *ind_type_neg_one = mm_strdup("-1");
 
                if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
                    mmfatal(INDICATOR_NOT_SIMPLE, "indicator for simple data type has to be simple");
 
                ECPGdump_a_simple(o, name, type->type, NULL, str_neg_one, NULL, prefix, 0);
                if (ind_type != NULL)
                    ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, ind_type_neg_one, NULL, ind_prefix, 0);
 
                free(str_neg_one);
                free(ind_type_neg_one);
            }
            break;
        default:
            {
                /*
                 * Allocate for each, as there are code-paths where the values
                 * get stomped on.
                 */
                char       *str_neg_one = mm_strdup("-1");
                char       *ind_type_neg_one = mm_strdup("-1");
 
                if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
                    mmfatal(INDICATOR_NOT_SIMPLE, "indicator for simple data type has to be simple");
 
                ECPGdump_a_simple(o, name, type->type, type->size, (arr_str_size && strcmp(arr_str_size, "0") != 0) ? arr_str_size : str_neg_one, struct_sizeof, prefix, type->counter);
                if (ind_type != NULL)
                    ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, (arr_str_size && strcmp(arr_str_size, "0") != 0) ? arr_str_size : ind_type_neg_one, ind_struct_sizeof, ind_prefix, 0);
 
                free(str_neg_one);
                free(ind_type_neg_one);
            }
            break;
    }
}

References base_yyerror(), variable::brace_level, ECPGdump_a_simple(), ECPGdump_a_struct(), ECPGt_array, ECPGt_char_variable, ECPGt_const, ECPGt_descriptor, ECPGt_NO_INDICATOR, ECPGt_sqlda, ECPGt_struct, ECPGt_union, ET_ERROR, ET_WARNING, fb(), find_variable(), free, variable::ind_type, INDICATOR_NOT_ARRAY, INDICATOR_NOT_SIMPLE, INDICATOR_NOT_STRUCT, indicator_set, IS_SIMPLE_TYPE, mm_strdup(), mmerror(), mmfatal(), name, PARSE_ERROR, str, type, and variable::type.

Referenced by dump_variables(), ECPGdump_a_struct(), output_get_descr(), and output_set_descr().

ECPGfree_struct_member()

void ECPGfree_struct_member

(

struct ECPGstruct_member *

rm

)

Definition at line 621 of file type.c.

{
    while (rm)
    {
        struct ECPGstruct_member *p = rm;
 
        rm = rm->next;
        free(p->name);
        ECPGfree_type(p->type);
        free(p);
    }
}

References ECPGfree_type(), free, ECPGstruct_member::name, ECPGstruct_member::next, and ECPGstruct_member::type.

Referenced by ECPGfree_type(), main(), and remove_typedefs().

ECPGfree_type()

void ECPGfree_type

(

struct ECPGtype *

type

)

Definition at line 635 of file type.c.

{
    if (!IS_SIMPLE_TYPE(type->type))
    {
        switch (type->type)
        {
            case ECPGt_array:
                switch (type->u.element->type)
                {
                    case ECPGt_array:
                        base_yyerror("internal error: found multidimensional array\n");
                        break;
                    case ECPGt_struct:
                    case ECPGt_union:
                        /* Array of structs. */
                        ECPGfree_type(type->u.element);
                        break;
                    default:
                        if (!IS_SIMPLE_TYPE(type->u.element->type))
                            base_yyerror("internal error: unknown datatype, please report this to <" PACKAGE_BUGREPORT ">");
 
                        ECPGfree_type(type->u.element);
                }
                break;
            case ECPGt_struct:
            case ECPGt_union:
                ECPGfree_struct_member(type->u.members);
                break;
            default:
                mmerror(PARSE_ERROR, ET_ERROR, "unrecognized variable type code %d", type->type);
                break;
        }
    }
    free(type->type_name);
    free(type->size);
    free(type->struct_sizeof);
    free(type);
}

References base_yyerror(), ECPGfree_struct_member(), ECPGfree_type(), ECPGt_array, ECPGt_struct, ECPGt_union, ET_ERROR, fb(), free, IS_SIMPLE_TYPE, mmerror(), PARSE_ERROR, and type.

Referenced by ECPGfree_struct_member(), ECPGfree_type(), and remove_variables().

ECPGmake_array_type()

struct ECPGtype * ECPGmake_array_type	(	struct ECPGtype *	type,
		const char *	size
	)

Definition at line 87 of file type.c.

{
    struct ECPGtype *ne = ECPGmake_simple_type(ECPGt_array, size, 0);
 
    ne->u.element = type;
 
    return ne;
}

References ECPGmake_simple_type(), ECPGt_array, fb(), ECPGtype::size, and type.

Referenced by ECPGstruct_member_dup(), find_struct_member(), and find_variable().

ECPGmake_simple_type()

struct ECPGtype * ECPGmake_simple_type	(	enum ECPGttype	type,
		const char *	size,
		int	counter
	)

Definition at line 72 of file type.c.

{
    struct ECPGtype *ne = (struct ECPGtype *) mm_alloc(sizeof(struct ECPGtype));
 
    ne->type = type;
    ne->type_name = NULL;
    ne->size = mm_strdup(size);
    ne->u.element = NULL;
    ne->struct_sizeof = NULL;
    ne->counter = counter;      /* only needed for varchar and bytea */
 
    return ne;
}

References ECPGtype::counter, fb(), mm_alloc(), mm_strdup(), ECPGtype::size, type, and ECPGtype::type.

Referenced by ECPGmake_array_type(), ECPGmake_struct_type(), ECPGstruct_member_dup(), find_struct_member(), and find_variable().

ECPGmake_struct_member()

void ECPGmake_struct_member	(	const char *	name,
		struct ECPGtype *	type,
		struct ECPGstruct_member **	start
	)

Definition at line 53 of file type.c.

{
    struct ECPGstruct_member *ptr,
               *ne =
        (struct ECPGstruct_member *) mm_alloc(sizeof(struct ECPGstruct_member));
 
    ne->name = mm_strdup(name);
    ne->type = type;
    ne->next = NULL;
 
    for (ptr = *start; ptr && ptr->next; ptr = ptr->next);
 
    if (ptr)
        ptr->next = ne;
    else
        *start = ne;
}

References fb(), mm_alloc(), mm_strdup(), name, ECPGstruct_member::name, ECPGstruct_member::next, start, and type.

Referenced by ECPGstruct_member_dup().

ECPGmake_struct_type()

struct ECPGtype * ECPGmake_struct_type	(	struct ECPGstruct_member *	rm,
		enum ECPGttype	type,
		const char *	type_name,
		const char *	struct_sizeof
	)

Definition at line 97 of file type.c.

{
    struct ECPGtype *ne = ECPGmake_simple_type(type, "1", 0);
 
    ne->type_name = mm_strdup(type_name);
    ne->u.members = ECPGstruct_member_dup(rm);
    ne->struct_sizeof = mm_strdup(struct_sizeof);
 
    return ne;
}

References ECPGmake_simple_type(), ECPGstruct_member_dup(), fb(), mm_strdup(), ECPGtype::struct_sizeof, type, and ECPGtype::type_name.

Referenced by ECPGstruct_member_dup(), find_struct_member(), and find_variable().

ECPGstruct_member_dup()

struct ECPGstruct_member * ECPGstruct_member_dup

(

struct ECPGstruct_member *

rm

)

Definition at line 13 of file type.c.

{
    struct ECPGstruct_member *new = NULL;
 
    while (rm)
    {
        struct ECPGtype *type;
 
        switch (rm->type->type)
        {
            case ECPGt_struct:
            case ECPGt_union:
                type = ECPGmake_struct_type(rm->type->u.members, rm->type->type, rm->type->type_name, rm->type->struct_sizeof);
                break;
            case ECPGt_array:
 
                /*
                 * if this array does contain a struct again, we have to
                 * create the struct too
                 */
                if (rm->type->u.element->type == ECPGt_struct || rm->type->u.element->type == ECPGt_union)
                    type = ECPGmake_struct_type(rm->type->u.element->u.members, rm->type->u.element->type, rm->type->u.element->type_name, rm->type->u.element->struct_sizeof);
                else
                    type = ECPGmake_array_type(ECPGmake_simple_type(rm->type->u.element->type, rm->type->u.element->size, rm->type->u.element->counter), rm->type->size);
                break;
            default:
                type = ECPGmake_simple_type(rm->type->type, rm->type->size, rm->type->counter);
                break;
        }
 
        ECPGmake_struct_member(rm->name, type, &new);
 
        rm = rm->next;
    }
 
    return new;
}

References ECPGtype::counter, ECPGmake_array_type(), ECPGmake_simple_type(), ECPGmake_struct_member(), ECPGmake_struct_type(), ECPGt_array, ECPGt_struct, ECPGt_union, ECPGtype::element, fb(), ECPGtype::members, ECPGstruct_member::name, ECPGstruct_member::next, ECPGtype::size, ECPGtype::struct_sizeof, type, ECPGstruct_member::type, ECPGtype::type, ECPGtype::type_name, and ECPGtype::u.

Referenced by ECPGmake_struct_type().

get_dtype()

const char * get_dtype

(

enum ECPGdtype

type

)

Definition at line 675 of file type.c.

{
    switch (type)
    {
        case ECPGd_count:
            return "ECPGd_count";
            break;
        case ECPGd_data:
            return "ECPGd_data";
            break;
        case ECPGd_di_code:
            return "ECPGd_di_code";
            break;
        case ECPGd_di_precision:
            return "ECPGd_di_precision";
            break;
        case ECPGd_indicator:
            return "ECPGd_indicator";
            break;
        case ECPGd_key_member:
            return "ECPGd_key_member";
            break;
        case ECPGd_length:
            return "ECPGd_length";
            break;
        case ECPGd_name:
            return "ECPGd_name";
            break;
        case ECPGd_nullable:
            return "ECPGd_nullable";
            break;
        case ECPGd_octet:
            return "ECPGd_octet";
            break;
        case ECPGd_precision:
            return "ECPGd_precision";
            break;
        case ECPGd_ret_length:
            return "ECPGd_ret_length";
        case ECPGd_ret_octet:
            return "ECPGd_ret_octet";
            break;
        case ECPGd_scale:
            return "ECPGd_scale";
            break;
        case ECPGd_type:
            return "ECPGd_type";
            break;
        case ECPGd_cardinality:
            return "ECPGd_cardinality";
        default:
            mmerror(PARSE_ERROR, ET_ERROR, "unrecognized descriptor item code %d", type);
    }
 
    return NULL;
}

References ECPGd_cardinality, ECPGd_count, ECPGd_data, ECPGd_di_code, ECPGd_di_precision, ECPGd_indicator, ECPGd_key_member, ECPGd_length, ECPGd_name, ECPGd_nullable, ECPGd_octet, ECPGd_precision, ECPGd_ret_length, ECPGd_ret_octet, ECPGd_scale, ECPGd_type, ET_ERROR, fb(), mmerror(), PARSE_ERROR, and type.

Referenced by output_get_descr(), and output_set_descr().

get_type()

static const char * get_type ( enum ECPGttype  type )

static

Definition at line 110 of file type.c.

{
    switch (type)
    {
        case ECPGt_char:
            return "ECPGt_char";
            break;
        case ECPGt_unsigned_char:
            return "ECPGt_unsigned_char";
            break;
        case ECPGt_short:
            return "ECPGt_short";
            break;
        case ECPGt_unsigned_short:
            return "ECPGt_unsigned_short";
            break;
        case ECPGt_int:
            return "ECPGt_int";
            break;
        case ECPGt_unsigned_int:
            return "ECPGt_unsigned_int";
            break;
        case ECPGt_long:
            return "ECPGt_long";
            break;
        case ECPGt_unsigned_long:
            return "ECPGt_unsigned_long";
            break;
        case ECPGt_long_long:
            return "ECPGt_long_long";
            break;
        case ECPGt_unsigned_long_long:
            return "ECPGt_unsigned_long_long";
            break;
        case ECPGt_float:
            return "ECPGt_float";
            break;
        case ECPGt_double:
            return "ECPGt_double";
            break;
        case ECPGt_bool:
            return "ECPGt_bool";
            break;
        case ECPGt_varchar:
            return "ECPGt_varchar";
        case ECPGt_bytea:
            return "ECPGt_bytea";
        case ECPGt_NO_INDICATOR:    /* no indicator */
            return "ECPGt_NO_INDICATOR";
            break;
        case ECPGt_char_variable:   /* string that should not be quoted */
            return "ECPGt_char_variable";
            break;
        case ECPGt_const:       /* constant string quoted */
            return "ECPGt_const";
            break;
        case ECPGt_decimal:
            return "ECPGt_decimal";
            break;
        case ECPGt_numeric:
            return "ECPGt_numeric";
            break;
        case ECPGt_interval:
            return "ECPGt_interval";
            break;
        case ECPGt_descriptor:
            return "ECPGt_descriptor";
            break;
        case ECPGt_sqlda:
            return "ECPGt_sqlda";
            break;
        case ECPGt_date:
            return "ECPGt_date";
            break;
        case ECPGt_timestamp:
            return "ECPGt_timestamp";
            break;
        case ECPGt_string:
            return "ECPGt_string";
            break;
        default:
            mmerror(PARSE_ERROR, ET_ERROR, "unrecognized variable type code %d", type);
    }
 
    return NULL;
}

References ECPGt_bool, ECPGt_bytea, ECPGt_char, ECPGt_char_variable, ECPGt_const, ECPGt_date, ECPGt_decimal, ECPGt_descriptor, ECPGt_double, ECPGt_float, ECPGt_int, ECPGt_interval, ECPGt_long, ECPGt_long_long, ECPGt_NO_INDICATOR, ECPGt_numeric, ECPGt_short, ECPGt_sqlda, ECPGt_string, ECPGt_timestamp, ECPGt_unsigned_char, ECPGt_unsigned_int, ECPGt_unsigned_long, ECPGt_unsigned_long_long, ECPGt_unsigned_short, ECPGt_varchar, ET_ERROR, fb(), mmerror(), PARSE_ERROR, and type.

Referenced by ECPGdump_a_simple().

Variable Documentation

struct_no_indicator

struct ECPGstruct_member struct_no_indicator = {"no_indicator", &ecpg_no_indicator, NULL}

static

Definition at line 9 of file type.c.

{"no_indicator", &ecpg_no_indicator, NULL};

Referenced by ECPGdump_a_struct().