descriptor.c

Go to the documentation of this file.

/*
 * functions needed for descriptor handling
 *
 * src/interfaces/ecpg/preproc/descriptor.c
 *
 * since descriptor might be either a string constant or a string var
 * we need to check for a constant if we expect a constant
 */
 
#include "postgres_fe.h"
 
#include "preproc_extern.h"
 
/*
 * assignment handling function (descriptor)
 */
 
static struct assignment *assignments;
 
void
push_assignment(const char *var, enum ECPGdtype value)
{
    struct assignment *new = (struct assignment *) mm_alloc(sizeof(struct assignment));
 
    new->next = assignments;
    new->variable = mm_strdup(var);
    new->value = value;
    assignments = new;
}
 
static void
drop_assignments(void)
{
    while (assignments)
    {
        struct assignment *old_head = assignments;
 
        assignments = old_head->next;
        free(old_head->variable);
        free(old_head);
    }
}
 
static void
ECPGnumeric_lvalue(char *name)
{
    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;
    }
}
 
/*
 * descriptor name lookup
 */
 
static struct descriptor *descriptors;
 
void
add_descriptor(const char *name, const char *connection)
{
    struct descriptor *new;
 
    if (name[0] != '"')
        return;
 
    new = (struct descriptor *) mm_alloc(sizeof(struct descriptor));
 
    new->next = descriptors;
    new->name = mm_strdup(name);
    if (connection)
        new->connection = mm_strdup(connection);
    else
        new->connection = NULL;
    descriptors = new;
}
 
void
drop_descriptor(const char *name, const char *connection)
{
    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);
}
 
struct descriptor *
lookup_descriptor(const char *name, const char *connection)
{
    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;
}
 
void
output_get_descr_header(const char *desc_name)
{
    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);
}
 
void
output_get_descr(const char *desc_name, const char *index)
{
    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);
}
 
void
output_set_descr_header(const char *desc_name)
{
    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);
}
 
static const char *
descriptor_item_name(enum ECPGdtype itemcode)
{
    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;
    }
}
 
void
output_set_descr(const char *desc_name, const char *index)
{
    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);
}
 
/* I consider dynamic allocation overkill since at most two descriptor
   variables are possible per statement. (input and output descriptor)
   And descriptors are no normal variables, so they don't belong into
   the variable list.
*/
 
#define MAX_DESCRIPTOR_NAMELEN 128
struct variable *
descriptor_variable(const char *name, int input)
{
    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];
}
 
struct variable *
sqlda_variable(const char *name)
{
    /*
     * Presently, sqlda variables are only needed for the duration of the
     * current statement.  Rather than add infrastructure to manage them,
     * let's just loc_alloc them.
     */
    struct variable *p = (struct variable *) loc_alloc(sizeof(struct variable));
 
    p->name = loc_strdup(name);
    p->type = (struct ECPGtype *) loc_alloc(sizeof(struct ECPGtype));
    p->type->type = ECPGt_sqlda;
    p->type->type_name = NULL;
    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;
}