type.h File Reference

#include "ecpgtype.h"

Include dependency graph for type.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ECPGstruct_member
struct	ECPGtype
struct	ECPGtemp_type
struct	when
struct	index
struct	su_symbol
struct	prep
struct	exec
struct	this_type
struct	_include_path
struct	cursor
struct	declared_list
struct	typedefs
struct	_defines
struct	variable
struct	arguments
struct	descriptor
struct	assignment
struct	fetch_desc
struct	describe

Enumerations
enum	WHEN_TYPE {   W_NOTHING , W_CONTINUE , W_BREAK , W_SQLPRINT ,   W_GOTO , W_DO , W_STOP }
enum	errortype { ET_WARNING , ET_ERROR }

Functions
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)
struct ECPGstruct_member *	ECPGstruct_member_dup (struct ECPGstruct_member *rm)
void	ECPGfree_struct_member (struct ECPGstruct_member *rm)
void	ECPGfree_type (struct ECPGtype *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)
const char *	ecpg_type_name (enum ECPGttype type)

Enumeration Type Documentation

errortype

enum errortype

Enumerator
ET_WARNING
ET_ERROR

Definition at line 218 of file type.h.

{
    ET_WARNING, ET_ERROR
};

WHEN_TYPE

enum WHEN_TYPE

Enumerator
W_NOTHING
W_CONTINUE
W_BREAK
W_SQLPRINT
W_GOTO
W_DO
W_STOP

Definition at line 77 of file type.h.

{
    W_NOTHING,
    W_CONTINUE,
    W_BREAK,
    W_SQLPRINT,
    W_GOTO,
    W_DO,
    W_STOP
};

Function Documentation

ecpg_type_name()

const char * ecpg_type_name

(

enum ECPGttype

type

)

Definition at line 17 of file typename.c.

{
    switch (typ)
    {
        case ECPGt_char:
        case ECPGt_string:
            return "char";
        case ECPGt_unsigned_char:
            return "unsigned char";
        case ECPGt_short:
            return "short";
        case ECPGt_unsigned_short:
            return "unsigned short";
        case ECPGt_int:
            return "int";
        case ECPGt_unsigned_int:
            return "unsigned int";
        case ECPGt_long:
            return "long";
        case ECPGt_unsigned_long:
            return "unsigned long";
        case ECPGt_long_long:
            return "long long";
        case ECPGt_unsigned_long_long:
            return "unsigned long long";
        case ECPGt_float:
            return "float";
        case ECPGt_double:
            return "double";
        case ECPGt_bool:
            return "bool";
        case ECPGt_varchar:
            return "varchar";
        case ECPGt_bytea:
            return "bytea";
        case ECPGt_char_variable:
            return "char";
        case ECPGt_decimal:
            return "decimal";
        case ECPGt_numeric:
            return "numeric";
        case ECPGt_date:
            return "date";
        case ECPGt_timestamp:
            return "timestamp";
        case ECPGt_interval:
            return "interval";
        case ECPGt_const:
            return "Const";
        default:
            abort();
    }
    return "";                  /* keep MSC compiler happy */
}

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 218 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, 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 618 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 632 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, 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, ECPGtype::element, ECPGtype::size, type, and ECPGtype::u.

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, ECPGtype::element, mm_alloc(), mm_strdup(), ECPGtype::size, ECPGtype::struct_sizeof, type, ECPGtype::type, ECPGtype::type_name, and ECPGtype::u.

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 mm_alloc(), mm_strdup(), name, ECPGstruct_member::name, ECPGstruct_member::next, start, type, and ECPGstruct_member::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(), ECPGtype::members, mm_strdup(), ECPGtype::struct_sizeof, type, ECPGtype::type_name, and ECPGtype::u.

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, 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().