descriptor.c File Reference

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

Include dependency graph for descriptor.c:

Go to the source code of this file.

Macros
#define	MAX_DESCRIPTOR_NAMELEN   128

Functions
void	push_assignment (char *var, enum ECPGdtype value)
static void	drop_assignments (void)
static void	ECPGnumeric_lvalue (char *name)
void	add_descriptor (char *name, char *connection)
void	drop_descriptor (char *name, char *connection)
struct descriptor *	lookup_descriptor (char *name, char *connection)
void	output_get_descr_header (char *desc_name)
void	output_get_descr (char *desc_name, char *index)
void	output_set_descr_header (char *desc_name)
static const char *	descriptor_item_name (enum ECPGdtype itemcode)
void	output_set_descr (char *desc_name, char *index)
struct variable *	descriptor_variable (const char *name, int input)
struct variable *	sqlda_variable (const char *name)

Variables
static struct assignment *	assignments
static struct descriptor *	descriptors

Macro Definition Documentation

MAX_DESCRIPTOR_NAMELEN

#define MAX_DESCRIPTOR_NAMELEN   128

Definition at line 335 of file descriptor.c.

Function Documentation

add_descriptor()

void add_descriptor	(	char *	name,
		char *	connection
	)

Definition at line 76 of file descriptor.c.

{
    struct descriptor *new;
 
    if (name[0] != '"')
        return;
 
    new = (struct descriptor *) mm_alloc(sizeof(struct descriptor));
 
    new->next = descriptors;
    new->name = mm_alloc(strlen(name) + 1);
    strcpy(new->name, name);
    if (connection)
    {
        new->connection = mm_alloc(strlen(connection) + 1);
        strcpy(new->connection, connection);
    }
    else
        new->connection = connection;
    descriptors = new;
}

References connection, descriptors, mm_alloc(), name, and descriptor::name.

descriptor_item_name()

static const char* descriptor_item_name ( enum ECPGdtype  itemcode )

static

Definition at line 233 of file descriptor.c.

{
    switch (itemcode)
    {
        case ECPGd_cardinality:
            return "CARDINALITY";
        case ECPGd_count:
            return "COUNT";
        case ECPGd_data:
            return "DATA";
        case ECPGd_di_code:
            return "DATETIME_INTERVAL_CODE";
        case ECPGd_di_precision:
            return "DATETIME_INTERVAL_PRECISION";
        case ECPGd_indicator:
            return "INDICATOR";
        case ECPGd_key_member:
            return "KEY_MEMBER";
        case ECPGd_length:
            return "LENGTH";
        case ECPGd_name:
            return "NAME";
        case ECPGd_nullable:
            return "NULLABLE";
        case ECPGd_octet:
            return "OCTET_LENGTH";
        case ECPGd_precision:
            return "PRECISION";
        case ECPGd_ret_length:
            return "RETURNED_LENGTH";
        case ECPGd_ret_octet:
            return "RETURNED_OCTET_LENGTH";
        case ECPGd_scale:
            return "SCALE";
        case ECPGd_type:
            return "TYPE";
        default:
            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, and ECPGd_type.

Referenced by output_set_descr().

descriptor_variable()

struct variable* descriptor_variable	(	const char *	name,
		int	input
	)

Definition at line 337 of file descriptor.c.

{
    static char descriptor_names[2][MAX_DESCRIPTOR_NAMELEN];
    static struct ECPGtype descriptor_type = {ECPGt_descriptor, NULL, NULL, NULL, {NULL}, 0};
    static struct variable varspace[2] = {
        {descriptor_names[0], &descriptor_type, 0, NULL},
        {descriptor_names[1], &descriptor_type, 0, NULL}
    };
 
    strlcpy(descriptor_names[input], name, sizeof(descriptor_names[input]));
    return &varspace[input];
}

References ECPGt_descriptor, input, MAX_DESCRIPTOR_NAMELEN, name, and strlcpy().

drop_assignments()

static void drop_assignments ( void  )

static

Definition at line 33 of file descriptor.c.

{
    while (assignments)
    {
        struct assignment *old_head = assignments;
 
        assignments = old_head->next;
        free(old_head->variable);
        free(old_head);
    }
}

References assignments, free, assignment::next, and assignment::variable.

Referenced by output_get_descr(), output_get_descr_header(), output_set_descr(), and output_set_descr_header().

drop_descriptor()

void drop_descriptor	(	char *	name,
		char *	connection
	)

Definition at line 99 of file descriptor.c.

{
    struct descriptor *i;
    struct descriptor **lastptr = &descriptors;
 
    if (name[0] != '"')
        return;
 
    for (i = descriptors; i; lastptr = &i->next, i = i->next)
    {
        if (strcmp(name, i->name) == 0)
        {
            if ((!connection && !i->connection)
                || (connection && i->connection
                    && strcmp(connection, i->connection) == 0))
            {
                *lastptr = i->next;
                free(i->connection);
                free(i->name);
                free(i);
                return;
            }
        }
    }
    if (connection)
        mmerror(PARSE_ERROR, ET_WARNING, "descriptor %s bound to connection %s does not exist", name, connection);
    else
        mmerror(PARSE_ERROR, ET_WARNING, "descriptor %s bound to the default connection does not exist", name);
}

References descriptors, ET_WARNING, free, i, mmerror(), name, and PARSE_ERROR.

ECPGnumeric_lvalue()

static void ECPGnumeric_lvalue ( char *  name )

static

Definition at line 46 of file descriptor.c.

{
    const struct variable *v = find_variable(name);
 
    switch (v->type->type)
    {
        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:
        case ECPGt_const:
            fputs(name, base_yyout);
            break;
        default:
            mmerror(PARSE_ERROR, ET_ERROR, "variable \"%s\" must have a numeric type", name);
            break;
    }
}

References base_yyout, ECPGt_const, ECPGt_int, ECPGt_long, ECPGt_long_long, ECPGt_short, ECPGt_unsigned_int, ECPGt_unsigned_long, ECPGt_unsigned_long_long, ECPGt_unsigned_short, ET_ERROR, find_variable(), mmerror(), name, PARSE_ERROR, and variable::type.

Referenced by output_get_descr_header(), and output_set_descr_header().

lookup_descriptor()

struct descriptor* lookup_descriptor	(	char *	name,
		char *	connection
	)

Definition at line 131 of file descriptor.c.

{
    struct descriptor *i;
 
    if (name[0] != '"')
        return NULL;
 
    for (i = descriptors; i; i = i->next)
    {
        if (strcmp(name, i->name) == 0)
        {
            if ((!connection && !i->connection)
                || (connection && i->connection
                    && strcmp(connection, i->connection) == 0))
                return i;
            if (connection && !i->connection)
            {
                /* overwrite descriptor's connection */
                i->connection = mm_strdup(connection);
                return i;
            }
        }
    }
    if (connection)
        mmerror(PARSE_ERROR, ET_WARNING, "descriptor %s bound to connection %s does not exist", name, connection);
    else
        mmerror(PARSE_ERROR, ET_WARNING, "descriptor %s bound to the default connection does not exist", name);
    return NULL;
}

References descriptors, ET_WARNING, i, mm_strdup(), mmerror(), name, and PARSE_ERROR.

output_get_descr()

void output_get_descr	(	char *	desc_name,
		char *	index
	)

Definition at line 181 of file descriptor.c.

{
    struct assignment *results;
 
    fprintf(base_yyout, "{ ECPGget_desc(__LINE__, %s, %s,", desc_name, index);
    for (results = assignments; results != NULL; results = results->next)
    {
        const struct variable *v = find_variable(results->variable);
        char       *str_zero = mm_strdup("0");
 
        switch (results->value)
        {
            case ECPGd_nullable:
                mmerror(PARSE_ERROR, ET_WARNING, "nullable is always 1");
                break;
            case ECPGd_key_member:
                mmerror(PARSE_ERROR, ET_WARNING, "key_member is always 0");
                break;
            default:
                break;
        }
        fprintf(base_yyout, "%s,", get_dtype(results->value));
        ECPGdump_a_type(base_yyout, v->name, v->type, v->brace_level,
                        NULL, NULL, -1, NULL, NULL, str_zero, NULL, NULL);
        free(str_zero);
    }
    drop_assignments();
    fputs("ECPGd_EODT);\n", base_yyout);
 
    whenever_action(2 | 1);
}

References assignments, base_yyout, variable::brace_level, drop_assignments(), ECPGd_key_member, ECPGd_nullable, ECPGdump_a_type(), ET_WARNING, find_variable(), fprintf, free, get_dtype(), mm_strdup(), mmerror(), variable::name, assignment::next, PARSE_ERROR, variable::type, assignment::value, assignment::variable, and whenever_action().

output_get_descr_header()

void output_get_descr_header

(

char *

desc_name

)

Definition at line 162 of file descriptor.c.

{
    struct assignment *results;
 
    fprintf(base_yyout, "{ ECPGget_desc_header(__LINE__, %s, &(", desc_name);
    for (results = assignments; results != NULL; results = results->next)
    {
        if (results->value == ECPGd_count)
            ECPGnumeric_lvalue(results->variable);
        else
            mmerror(PARSE_ERROR, ET_WARNING, "descriptor header item \"%d\" does not exist", results->value);
    }
 
    drop_assignments();
    fprintf(base_yyout, "));\n");
    whenever_action(3);
}

References assignments, base_yyout, drop_assignments(), ECPGd_count, ECPGnumeric_lvalue(), ET_WARNING, fprintf, mmerror(), assignment::next, PARSE_ERROR, assignment::value, assignment::variable, and whenever_action().

output_set_descr()

void output_set_descr	(	char *	desc_name,
		char *	index
	)

Definition at line 275 of file descriptor.c.

{
    struct assignment *results;
 
    fprintf(base_yyout, "{ ECPGset_desc(__LINE__, %s, %s,", desc_name, index);
    for (results = assignments; results != NULL; results = results->next)
    {
        const struct variable *v = find_variable(results->variable);
 
        switch (results->value)
        {
            case ECPGd_cardinality:
            case ECPGd_di_code:
            case ECPGd_di_precision:
            case ECPGd_precision:
            case ECPGd_scale:
                mmfatal(PARSE_ERROR, "descriptor item \"%s\" is not implemented",
                        descriptor_item_name(results->value));
                break;
 
            case ECPGd_key_member:
            case ECPGd_name:
            case ECPGd_nullable:
            case ECPGd_octet:
            case ECPGd_ret_length:
            case ECPGd_ret_octet:
                mmfatal(PARSE_ERROR, "descriptor item \"%s\" cannot be set",
                        descriptor_item_name(results->value));
                break;
 
            case ECPGd_data:
            case ECPGd_indicator:
            case ECPGd_length:
            case ECPGd_type:
                {
                    char       *str_zero = mm_strdup("0");
 
                    fprintf(base_yyout, "%s,", get_dtype(results->value));
                    ECPGdump_a_type(base_yyout, v->name, v->type, v->brace_level,
                                    NULL, NULL, -1, NULL, NULL, str_zero, NULL, NULL);
                    free(str_zero);
                }
                break;
 
            default:
                ;
        }
    }
    drop_assignments();
    fputs("ECPGd_EODT);\n", base_yyout);
 
    whenever_action(2 | 1);
}

References assignments, base_yyout, variable::brace_level, descriptor_item_name(), drop_assignments(), ECPGd_cardinality, 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, ECPGdump_a_type(), find_variable(), fprintf, free, get_dtype(), mm_strdup(), mmfatal(), variable::name, assignment::next, PARSE_ERROR, variable::type, assignment::value, assignment::variable, and whenever_action().

output_set_descr_header()

void output_set_descr_header

(

char *

desc_name

)

Definition at line 214 of file descriptor.c.

{
    struct assignment *results;
 
    fprintf(base_yyout, "{ ECPGset_desc_header(__LINE__, %s, (int)(", desc_name);
    for (results = assignments; results != NULL; results = results->next)
    {
        if (results->value == ECPGd_count)
            ECPGnumeric_lvalue(results->variable);
        else
            mmerror(PARSE_ERROR, ET_WARNING, "descriptor header item \"%d\" does not exist", results->value);
    }
 
    drop_assignments();
    fprintf(base_yyout, "));\n");
    whenever_action(3);
}

References assignments, base_yyout, drop_assignments(), ECPGd_count, ECPGnumeric_lvalue(), ET_WARNING, fprintf, mmerror(), assignment::next, PARSE_ERROR, assignment::value, assignment::variable, and whenever_action().

push_assignment()

void push_assignment	(	char *	var,
		enum ECPGdtype	value
	)

Definition at line 21 of file descriptor.c.

{
    struct assignment *new = (struct assignment *) mm_alloc(sizeof(struct assignment));
 
    new->next = assignments;
    new->variable = mm_alloc(strlen(var) + 1);
    strcpy(new->variable, var);
    new->value = value;
    assignments = new;
}

References assignments, mm_alloc(), value, and assignment::variable.

sqlda_variable()

struct variable* sqlda_variable

(

const char *

name

)

Definition at line 351 of file descriptor.c.

{
    struct variable *p = (struct variable *) mm_alloc(sizeof(struct variable));
 
    p->name = mm_strdup(name);
    p->type = (struct ECPGtype *) mm_alloc(sizeof(struct ECPGtype));
    p->type->type = ECPGt_sqlda;
    p->type->size = NULL;
    p->type->struct_sizeof = NULL;
    p->type->u.element = NULL;
    p->type->counter = 0;
    p->brace_level = 0;
    p->next = NULL;
 
    return p;
}

References variable::brace_level, ECPGt_sqlda, mm_alloc(), mm_strdup(), name, variable::name, variable::next, and variable::type.

Variable Documentation

assignments

struct assignment* assignments

static

Definition at line 18 of file descriptor.c.

Referenced by drop_assignments(), output_get_descr(), output_get_descr_header(), output_set_descr(), output_set_descr_header(), and push_assignment().

descriptors

struct descriptor* descriptors

static

Definition at line 73 of file descriptor.c.

Referenced by add_descriptor(), drop_descriptor(), and lookup_descriptor().