preproc_extern.h File Reference

#include "common/keywords.h"
#include "type.h"
#include <limits.h>

Include dependency graph for preproc_extern.h:

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

Go to the source code of this file.

Macros
#define	STRUCT_DEPTH   128
#define	YYLTYPE_IS_DECLARED   1
#define	ILLEGAL_OPTION   1
#define	NO_INCLUDE_FILE   2
#define	PARSE_ERROR   3
#define	INDICATOR_NOT_ARRAY   4
#define	OUT_OF_MEMORY   5
#define	INDICATOR_NOT_STRUCT   6
#define	INDICATOR_NOT_SIMPLE   7
#define	INFORMIX_MODE   (compat == ECPG_COMPAT_INFORMIX || compat == ECPG_COMPAT_INFORMIX_SE)
#define	ORACLE_MODE   (compat == ECPG_COMPAT_ORACLE)

Typedefs
typedef const char *	YYLTYPE

Enumerations
enum	COMPAT_MODE {   ECPG_COMPAT_PGSQL = 0 , ECPG_COMPAT_INFORMIX , ECPG_COMPAT_INFORMIX_SE , ECPG_COMPAT_ORACLE ,   ECPG_COMPAT_PGSQL = 0 , ECPG_COMPAT_INFORMIX , ECPG_COMPAT_INFORMIX_SE , ECPG_COMPAT_ORACLE }

Functions
const char *	get_dtype (enum ECPGdtype)
void	lex_init (void)
void	output_line_number (void)
void	output_statement (const char *stmt, int whenever_mode, enum ECPG_statement_type st)
void	output_prepare_statement (const char *name, const char *stmt)
void	output_deallocate_prepare_statement (const char *name)
void	output_simple_statement (const char *stmt, int whenever_mode)
char *	hashline_number (void)
int	base_yyparse (void)
int	base_yylex (void)
void	base_yyerror (const char *error)
void *	mm_alloc (size_t size)
char *	mm_strdup (const char *string)
void *	loc_alloc (size_t size)
char *	loc_strdup (const char *string)
void	reclaim_local_storage (void)
char *	cat2_str (const char *str1, const char *str2)
char *	cat_str (int count,...)
char *	make2_str (const char *str1, const char *str2)
char *	make3_str (const char *str1, const char *str2, const char *str3)
void	mmerror (int error_code, enum errortype type, const char *error,...) pg_attribute_printf(3
void void	mmfatal (int error_code, const char *error,...) pg_attribute_printf(2
void void	pg_attribute_noreturn ()
void	output_get_descr_header (const char *desc_name)
void	output_get_descr (const char *desc_name, const char *index)
void	output_set_descr_header (const char *desc_name)
void	output_set_descr (const char *desc_name, const char *index)
void	push_assignment (const char *var, enum ECPGdtype value)
struct variable *	find_variable (const char *name)
void	whenever_action (int mode)
void	add_descriptor (const char *name, const char *connection)
void	drop_descriptor (const char *name, const char *connection)
struct descriptor *	lookup_descriptor (const char *name, const char *connection)
struct variable *	descriptor_variable (const char *name, int input)
struct variable *	sqlda_variable (const char *name)
void	add_variable_to_head (struct arguments **list, struct variable *var, struct variable *ind)
void	add_variable_to_tail (struct arguments **list, struct variable *var, struct variable *ind)
void	remove_variable_from_list (struct arguments **list, struct variable *var)
void	dump_variables (struct arguments *list, int mode)
struct typedefs *	get_typedef (const char *name, bool noerror)
void	adjust_array (enum ECPGttype type_enum, const char **dimension, const char **length, const char *type_dimension, const char *type_index, int pointer_len, bool type_definition)
void	reset_variables (void)
void	check_indicator (struct ECPGtype *var)
void	remove_typedefs (int brace_level)
void	remove_variables (int brace_level)
struct variable *	new_variable (const char *name, struct ECPGtype *type, int brace_level)
int	ScanCKeywordLookup (const char *text)
int	ScanECPGKeywordLookup (const char *text)
void	parser_init (void)
int	filtered_base_yylex (void)

Variables
bool	autocommit
bool	auto_create_c
bool	system_includes
bool	force_indicator
bool	questionmarks
bool	regression_mode
bool	auto_prepare
int	braces_open
int	ret_value
int	struct_level
int	ecpg_internal_var
char *	current_function
char *	descriptor_name
char *	connection
char *	input_filename
char *	base_yytext
char *	token_start
int	base_yylineno
FILE *	base_yyin
FILE *	base_yyout
char *	output_filename
struct _include_path *	include_paths
struct cursor *	cur
struct typedefs *	types
struct _defines *	defines
struct declared_list *	g_declared_list
struct ECPGtype	ecpg_no_indicator
struct variable	no_indicator
struct arguments *	argsinsert
struct arguments *	argsresult
struct when when_error when_nf	when_warn
struct ECPGstruct_member *	struct_member_list [STRUCT_DEPTH]
const uint16	SQLScanKeywordTokens []
enum COMPAT_MODE	compat

Macro Definition Documentation

ILLEGAL_OPTION

#define ILLEGAL_OPTION   1

Definition at line 132 of file preproc_extern.h.

INDICATOR_NOT_ARRAY

#define INDICATOR_NOT_ARRAY   4

Definition at line 135 of file preproc_extern.h.

INDICATOR_NOT_SIMPLE

#define INDICATOR_NOT_SIMPLE   7

Definition at line 138 of file preproc_extern.h.

INDICATOR_NOT_STRUCT

#define INDICATOR_NOT_STRUCT   6

Definition at line 137 of file preproc_extern.h.

INFORMIX_MODE

#define INFORMIX_MODE   (compat == ECPG_COMPAT_INFORMIX || compat == ECPG_COMPAT_INFORMIX_SE)

Definition at line 146 of file preproc_extern.h.

NO_INCLUDE_FILE

#define NO_INCLUDE_FILE   2

Definition at line 133 of file preproc_extern.h.

ORACLE_MODE

#define ORACLE_MODE   (compat == ECPG_COMPAT_ORACLE)

Definition at line 147 of file preproc_extern.h.

OUT_OF_MEMORY

#define OUT_OF_MEMORY   5

Definition at line 136 of file preproc_extern.h.

PARSE_ERROR

#define PARSE_ERROR   3

Definition at line 134 of file preproc_extern.h.

STRUCT_DEPTH

#define STRUCT_DEPTH   128

Definition at line 15 of file preproc_extern.h.

YYLTYPE_IS_DECLARED

#define YYLTYPE_IS_DECLARED   1

Definition at line 22 of file preproc_extern.h.

Typedef Documentation

YYLTYPE

typedef const char* YYLTYPE

Definition at line 20 of file preproc_extern.h.

Enumeration Type Documentation

COMPAT_MODE

enum COMPAT_MODE

Enumerator
ECPG_COMPAT_PGSQL
ECPG_COMPAT_INFORMIX
ECPG_COMPAT_INFORMIX_SE
ECPG_COMPAT_ORACLE
ECPG_COMPAT_PGSQL
ECPG_COMPAT_INFORMIX
ECPG_COMPAT_INFORMIX_SE
ECPG_COMPAT_ORACLE

Definition at line 140 of file preproc_extern.h.

{
    ECPG_COMPAT_PGSQL = 0, ECPG_COMPAT_INFORMIX, ECPG_COMPAT_INFORMIX_SE, ECPG_COMPAT_ORACLE
};

Function Documentation

add_descriptor()

void add_descriptor	(	const char *	name,
		const char *	connection
	)

Definition at line 75 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_strdup(name);
    if (connection)
        new->connection = mm_strdup(connection);
    else
        new->connection = NULL;
    descriptors = new;
}

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

add_variable_to_head()

void add_variable_to_head	(	struct arguments **	list,
		struct variable *	var,
		struct variable *	ind
	)

Definition at line 401 of file variable.c.

{
    struct arguments *p = (struct arguments *) mm_alloc(sizeof(struct arguments));
 
    p->variable = var;
    p->indicator = ind;
    p->next = *list;
    *list = p;
}

References arguments::indicator, sort-test::list, mm_alloc(), arguments::next, and arguments::variable.

add_variable_to_tail()

void add_variable_to_tail	(	struct arguments **	list,
		struct variable *	var,
		struct variable *	ind
	)

Definition at line 413 of file variable.c.

{
    struct arguments *p,
               *new = (struct arguments *) mm_alloc(sizeof(struct arguments));
 
    for (p = *list; p && p->next; p = p->next);
 
    new->variable = var;
    new->indicator = ind;
    new->next = NULL;
 
    if (p)
        p->next = new;
    else
        *list = new;
}

References sort-test::list, mm_alloc(), and arguments::next.

adjust_array()

void adjust_array	(	enum ECPGttype	type_enum,
		const char **	dimension,
		const char **	length,
		const char *	type_dimension,
		const char *	type_index,
		int	pointer_len,
		bool	type_definition
	)

Definition at line 540 of file variable.c.

{
    if (atoi(type_index) >= 0)
    {
        if (atoi(*length) >= 0)
            mmfatal(PARSE_ERROR, "multidimensional arrays are not supported");
 
        *length = type_index;
    }
 
    if (atoi(type_dimension) >= 0)
    {
        if (atoi(*dimension) >= 0 && atoi(*length) >= 0)
            mmfatal(PARSE_ERROR, "multidimensional arrays are not supported");
 
        if (atoi(*dimension) >= 0)
            *length = *dimension;
 
        *dimension = type_dimension;
    }
 
    if (pointer_len > 2)
        mmfatal(PARSE_ERROR, ngettext("multilevel pointers (more than 2 levels) are not supported; found %d level",
                                      "multilevel pointers (more than 2 levels) are not supported; found %d levels", pointer_len),
                pointer_len);
 
    if (pointer_len > 1 && type_enum != ECPGt_char && type_enum != ECPGt_unsigned_char && type_enum != ECPGt_string)
        mmfatal(PARSE_ERROR, "pointer to pointer is not supported for this data type");
 
    if (pointer_len > 1 && (atoi(*length) >= 0 || atoi(*dimension) >= 0))
        mmfatal(PARSE_ERROR, "multidimensional arrays are not supported");
 
    if (atoi(*length) >= 0 && atoi(*dimension) >= 0 && pointer_len)
        mmfatal(PARSE_ERROR, "multidimensional arrays are not supported");
 
    switch (type_enum)
    {
        case ECPGt_struct:
        case ECPGt_union:
            /* pointer has to get dimension 0 */
            if (pointer_len)
            {
                *length = *dimension;
                *dimension = "0";
            }
 
            if (atoi(*length) >= 0)
                mmfatal(PARSE_ERROR, "multidimensional arrays for structures are not supported");
 
            break;
        case ECPGt_varchar:
        case ECPGt_bytea:
            /* pointer has to get dimension 0 */
            if (pointer_len)
                *dimension = "0";
 
            /* one index is the string length */
            if (atoi(*length) < 0)
            {
                *length = *dimension;
                *dimension = "-1";
            }
 
            break;
        case ECPGt_char:
        case ECPGt_unsigned_char:
        case ECPGt_string:
            /* char ** */
            if (pointer_len == 2)
            {
                *length = *dimension = "0";
                break;
            }
 
            /* pointer has to get length 0 */
            if (pointer_len == 1)
                *length = "0";
 
            /* one index is the string length */
            if (atoi(*length) < 0)
            {
                /*
                 * make sure we return length = -1 for arrays without given
                 * bounds
                 */
                if (atoi(*dimension) < 0 && !type_definition)
 
                    /*
                     * do not change this for typedefs since it will be
                     * changed later on when the variable is defined
                     */
                    *length = "1";
                else if (strcmp(*dimension, "0") == 0)
                    *length = "-1";
                else
                    *length = *dimension;
 
                *dimension = "-1";
            }
            break;
        default:
            /* a pointer has dimension = 0 */
            if (pointer_len)
            {
                *length = *dimension;
                *dimension = "0";
            }
 
            if (atoi(*length) >= 0)
                mmfatal(PARSE_ERROR, "multidimensional arrays for simple data types are not supported");
 
            break;
    }
}

References ECPGt_bytea, ECPGt_char, ECPGt_string, ECPGt_struct, ECPGt_union, ECPGt_unsigned_char, ECPGt_varchar, mmfatal(), ngettext, and PARSE_ERROR.

base_yyerror()

void base_yyerror

(

const char *

error

)

Referenced by ECPGdump_a_type(), and ECPGfree_type().

base_yylex()

int base_yylex

(

void

)

base_yyparse()

int base_yyparse

(

void

)

cat2_str()

char * cat2_str	(	const char *	str1,
		const char *	str2
	)

Definition at line 205 of file util.c.

{
    char       *res_str = (char *) loc_alloc(strlen(str1) + strlen(str2) + 2);
 
    strcpy(res_str, str1);
    if (strlen(str1) != 0 && strlen(str2) != 0)
        strcat(res_str, " ");
    strcat(res_str, str2);
    return res_str;
}

References loc_alloc().

Referenced by cat_str().

cat_str()

char * cat_str	(	int	count,
			...
	)

Definition at line 220 of file util.c.

{
    va_list     args;
    int         i;
    char       *res_str;
 
    va_start(args, count);
 
    res_str = va_arg(args, char *);
 
    /* now add all other strings */
    for (i = 1; i < count; i++)
        res_str = cat2_str(res_str, va_arg(args, char *));
 
    va_end(args);
 
    return res_str;
}

References generate_unaccent_rules::args, cat2_str(), i, va_end(), and va_start().

check_indicator()

void check_indicator

(

struct ECPGtype *

var

)

Definition at line 490 of file variable.c.

{
    /* make sure this is a valid indicator variable */
    switch (var->type)
    {
            struct ECPGstruct_member *p;
 
        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:
            break;
 
        case ECPGt_struct:
        case ECPGt_union:
            for (p = var->u.members; p; p = p->next)
                check_indicator(p->type);
            break;
 
        case ECPGt_array:
            check_indicator(var->u.element);
            break;
        default:
            mmerror(PARSE_ERROR, ET_ERROR, "indicator variable must have an integer type");
            break;
    }
}

References check_indicator(), ECPGt_array, ECPGt_int, ECPGt_long, ECPGt_long_long, ECPGt_short, ECPGt_struct, ECPGt_union, ECPGt_unsigned_int, ECPGt_unsigned_long, ECPGt_unsigned_long_long, ECPGt_unsigned_short, ECPGtype::element, ET_ERROR, ECPGtype::members, mmerror(), ECPGstruct_member::next, PARSE_ERROR, ECPGstruct_member::type, ECPGtype::type, and ECPGtype::u.

Referenced by check_indicator().

descriptor_variable()

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

Definition at line 331 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_descriptor()

void drop_descriptor	(	const char *	name,
		const char *	connection
	)

Definition at line 94 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.

dump_variables()

void dump_variables	(	struct arguments *	list,
		int	mode
	)

Definition at line 461 of file variable.c.

{
    char       *str_zero;
 
    if (list == NULL)
        return;
 
    str_zero = mm_strdup("0");
 
    /*
     * The list is build up from the beginning so lets first dump the end of
     * the list:
     */
 
    dump_variables(list->next, mode);
 
    /* Then the current element and its indicator */
    ECPGdump_a_type(base_yyout, list->variable->name, list->variable->type, list->variable->brace_level,
                    list->indicator->name, list->indicator->type, list->indicator->brace_level,
                    NULL, NULL, str_zero, NULL, NULL);
 
    /* Then release the list element. */
    if (mode != 0)
        free(list);
 
    free(str_zero);
}

References base_yyout, dump_variables(), ECPGdump_a_type(), free, sort-test::list, mm_strdup(), and mode.

Referenced by dump_variables(), and output_statement().

filtered_base_yylex()

int filtered_base_yylex

(

void

)

Definition at line 57 of file parser.c.

{
    int         cur_token;
    int         next_token;
    YYSTYPE     cur_yylval;
    YYLTYPE     cur_yylloc;
    char       *cur_yytext;
 
    /* Get next token --- we might already have it */
    if (have_lookahead)
    {
        cur_token = lookahead_token;
        base_yylval = lookahead_yylval;
        base_yylloc = lookahead_yylloc;
        base_yytext = lookahead_yytext;
        have_lookahead = false;
    }
    else
        cur_token = base_yylex_location();
 
    /*
     * If this token isn't one that requires lookahead, just return it.
     */
    switch (cur_token)
    {
        case FORMAT:
        case NOT:
        case NULLS_P:
        case WITH:
        case WITHOUT:
        case UIDENT:
        case USCONST:
            break;
        default:
            return cur_token;
    }
 
    /* Save and restore lexer output variables around the call */
    cur_yylval = base_yylval;
    cur_yylloc = base_yylloc;
    cur_yytext = base_yytext;
 
    /* Get next token, saving outputs into lookahead variables */
    next_token = base_yylex_location();
 
    lookahead_token = next_token;
    lookahead_yylval = base_yylval;
    lookahead_yylloc = base_yylloc;
    lookahead_yytext = base_yytext;
 
    base_yylval = cur_yylval;
    base_yylloc = cur_yylloc;
    base_yytext = cur_yytext;
 
    have_lookahead = true;
 
    /* Replace cur_token if needed, based on lookahead */
    switch (cur_token)
    {
        case FORMAT:
            /* Replace FORMAT by FORMAT_LA if it's followed by JSON */
            switch (next_token)
            {
                case JSON:
                    cur_token = FORMAT_LA;
                    break;
            }
            break;
 
        case NOT:
            /* Replace NOT by NOT_LA if it's followed by BETWEEN, IN, etc */
            switch (next_token)
            {
                case BETWEEN:
                case IN_P:
                case LIKE:
                case ILIKE:
                case SIMILAR:
                    cur_token = NOT_LA;
                    break;
            }
            break;
 
        case NULLS_P:
            /* Replace NULLS_P by NULLS_LA if it's followed by FIRST or LAST */
            switch (next_token)
            {
                case FIRST_P:
                case LAST_P:
                    cur_token = NULLS_LA;
                    break;
            }
            break;
 
        case WITH:
            /* Replace WITH by WITH_LA if it's followed by TIME or ORDINALITY */
            switch (next_token)
            {
                case TIME:
                case ORDINALITY:
                    cur_token = WITH_LA;
                    break;
            }
            break;
 
        case WITHOUT:
            /* Replace WITHOUT by WITHOUT_LA if it's followed by TIME */
            switch (next_token)
            {
                case TIME:
                    cur_token = WITHOUT_LA;
                    break;
            }
            break;
        case UIDENT:
        case USCONST:
            /* Look ahead for UESCAPE */
            if (next_token == UESCAPE)
            {
                /* Yup, so get third token, which had better be SCONST */
                const char *escstr;
 
                /*
                 * Again save and restore lexer output variables around the
                 * call
                 */
                cur_yylval = base_yylval;
                cur_yylloc = base_yylloc;
                cur_yytext = base_yytext;
 
                /* Get third token */
                next_token = base_yylex_location();
 
                if (next_token != SCONST)
                    mmerror(PARSE_ERROR, ET_ERROR, "UESCAPE must be followed by a simple string literal");
 
                /*
                 * Save and check escape string, which the scanner returns
                 * with quotes
                 */
                escstr = base_yylval.str;
                if (strlen(escstr) != 3 || !check_uescapechar(escstr[1]))
                    mmerror(PARSE_ERROR, ET_ERROR, "invalid Unicode escape character");
 
                base_yylval = cur_yylval;
                base_yylloc = cur_yylloc;
                base_yytext = cur_yytext;
 
                /* Combine 3 tokens into 1 */
                base_yylval.str = make3_str(base_yylval.str,
                                            " UESCAPE ",
                                            escstr);
                base_yylloc = loc_strdup(base_yylval.str);
 
                /* Clear have_lookahead, thereby consuming all three tokens */
                have_lookahead = false;
            }
 
            if (cur_token == UIDENT)
                cur_token = IDENT;
            else if (cur_token == USCONST)
                cur_token = SCONST;
            break;
    }
 
    return cur_token;
}

References base_yylex_location(), base_yylval, base_yytext, check_uescapechar(), ET_ERROR, have_lookahead, loc_strdup(), lookahead_token, lookahead_yylloc, lookahead_yylval, lookahead_yytext, make3_str(), mmerror(), next_token(), and PARSE_ERROR.

find_variable()

struct variable * find_variable

(

const char *

name

)

Definition at line 193 of file variable.c.

{
    char       *next,
               *end;
    struct variable *p;
    int         count;
 
    next = strpbrk(name, ".[-");
    if (next)
    {
        if (*next == '[')
        {
            /*
             * We don't care about what's inside the array braces so just eat
             * up the characters
             */
            for (count = 1, end = next + 1; count; end++)
            {
                switch (*end)
                {
                    case '[':
                        count++;
                        break;
                    case ']':
                        count--;
                        break;
                    case '\0':
                        mmfatal(PARSE_ERROR, "unmatched brace in variable \"%s\"", name);
                        break;
                    default:
                        break;
                }
            }
            if (*end == '.')
                p = find_struct(name, next, end);
            else
            {
                char        c = *next;
 
                *next = '\0';
                p = find_simple(name);
                if (p == NULL)
                    mmfatal(PARSE_ERROR, "variable \"%s\" is not declared", name);
                if (p->type->type != ECPGt_array)
                    mmfatal(PARSE_ERROR, "variable \"%s\" is not a pointer", name);
                *next = c;
                switch (p->type->u.element->type)
                {
                    case ECPGt_array:
                        return new_variable(name, ECPGmake_array_type(ECPGmake_simple_type(p->type->u.element->u.element->type, p->type->u.element->u.element->size, p->type->u.element->u.element->counter), p->type->u.element->size), p->brace_level);
                    case ECPGt_struct:
                    case ECPGt_union:
                        return new_variable(name, ECPGmake_struct_type(p->type->u.element->u.members, p->type->u.element->type, p->type->u.element->type_name, p->type->u.element->struct_sizeof), p->brace_level);
                    default:
                        return new_variable(name, ECPGmake_simple_type(p->type->u.element->type, p->type->u.element->size, p->type->u.element->counter), p->brace_level);
                }
            }
        }
        else
            p = find_struct(name, next, next);
    }
    else
        p = find_simple(name);
 
    if (p == NULL)
        mmfatal(PARSE_ERROR, "variable \"%s\" is not declared", name);
 
    return p;
}

References variable::brace_level, ECPGmake_array_type(), ECPGmake_simple_type(), ECPGmake_struct_type(), ECPGt_array, ECPGt_struct, ECPGt_union, find_simple(), find_struct(), mmfatal(), name, new_variable(), next, PARSE_ERROR, and variable::type.

Referenced by ECPGdump_a_type(), ECPGnumeric_lvalue(), find_struct(), output_get_descr(), and output_set_descr().

get_dtype()

const char * get_dtype

(

enum

ECPGdtype

)

Definition at line 672 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, mmerror(), PARSE_ERROR, and type.

Referenced by output_get_descr(), and output_set_descr().

get_typedef()

struct typedefs * get_typedef	(	const char *	name,
		bool	noerror
	)

Definition at line 523 of file variable.c.

{
    struct typedefs *this;
 
    for (this = types; this != NULL; this = this->next)
    {
        if (strcmp(this->name, name) == 0)
            return this;
    }
 
    if (!noerror)
        mmfatal(PARSE_ERROR, "unrecognized data type name \"%s\"", name);
 
    return NULL;
}

References mmfatal(), name, next, PARSE_ERROR, and types.

hashline_number()

char * hashline_number

(

void

)

Definition at line 92 of file output.c.

{
    /* do not print line numbers if we are in debug mode */
    if (input_filename
#ifdef YYDEBUG
        && !base_yydebug
#endif
        )
    {
        /* "* 2" here is for escaping '\' and '"' below */
        char       *line = loc_alloc(strlen("\n#line %d \"%s\"\n") + sizeof(int) * CHAR_BIT * 10 / 3 + strlen(input_filename) * 2);
        char       *src,
                   *dest;
 
        sprintf(line, "\n#line %d \"", base_yylineno);
        src = input_filename;
        dest = line + strlen(line);
        while (*src)
        {
            if (*src == '\\' || *src == '"')
                *dest++ = '\\';
            *dest++ = *src++;
        }
        *dest = '\0';
        strcat(dest, "\"\n");
 
        return line;
    }
 
    return "";
}

References base_yylineno, generate_unaccent_rules::dest, input_filename, loc_alloc(), and sprintf.

Referenced by output_line_number().

lex_init()

void lex_init

(

void

)

Definition at line 1616 of file pgc.l.

{
    braces_open = 0;
    parenths_open = 0;
    current_function = NULL;
 
    yylineno = 1;
 
    /* initialize state for if/else/endif */
    preproc_tos = 0;
    stacked_if_value[preproc_tos].active = true;
    stacked_if_value[preproc_tos].saw_active = true;
    stacked_if_value[preproc_tos].else_branch = false;
 
    /* initialize literal buffer to a reasonable but expansible size */
    if (literalbuf == NULL)
    {
        literalalloc = 1024;
        literalbuf = (char *) mm_alloc(literalalloc);
    }
    startlit();
 
    BEGIN(C);
}

References _if_value::active, braces_open, current_function, _if_value::else_branch, literalalloc, literalbuf, mm_alloc(), parenths_open, preproc_tos, _if_value::saw_active, stacked_if_value, and startlit.

Referenced by main().

loc_alloc()

void * loc_alloc

(

size_t

size

)

Definition at line 138 of file util.c.

{
    void       *result;
    loc_chunk  *cur_chunk = loc_chunks;
 
    /* Ensure all allocations are adequately aligned */
    size = MAXALIGN(size);
 
    /* Need a new chunk? */
    if (cur_chunk == NULL || size > cur_chunk->chunk_avail)
    {
        size_t      chunk_size = Max(size, LOC_CHUNK_MIN_SIZE);
 
        cur_chunk = mm_alloc(chunk_size + LOC_CHUNK_OVERHEAD);
        /* Depending on alignment rules, we could waste a bit here */
        cur_chunk->chunk_used = LOC_CHUNK_OVERHEAD - offsetof(loc_chunk, data);
        cur_chunk->chunk_avail = chunk_size;
        /* New chunk becomes the head of the list */
        cur_chunk->next = loc_chunks;
        loc_chunks = cur_chunk;
    }
 
    result = cur_chunk->data + cur_chunk->chunk_used;
    cur_chunk->chunk_used += size;
    cur_chunk->chunk_avail -= size;
    return result;
}

References loc_chunk::chunk_avail, loc_chunk::chunk_used, loc_chunk::data, data, LOC_CHUNK_MIN_SIZE, LOC_CHUNK_OVERHEAD, loc_chunks, Max, MAXALIGN, mm_alloc(), loc_chunk::next, and size.

Referenced by cat2_str(), hashline_number(), loc_strdup(), make2_str(), make3_str(), and sqlda_variable().

loc_strdup()

char * loc_strdup

(

const char *

string

)

Definition at line 170 of file util.c.

{
    char       *result = loc_alloc(strlen(string) + 1);
 
    strcpy(result, string);
    return result;
}

References loc_alloc().

Referenced by base_yylex_location(), filtered_base_yylex(), process_integer_literal(), and sqlda_variable().

lookup_descriptor()

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

Definition at line 125 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.

make2_str()

char * make2_str	(	const char *	str1,
		const char *	str2
	)

Definition at line 243 of file util.c.

{
    char       *res_str = (char *) loc_alloc(strlen(str1) + strlen(str2) + 1);
 
    strcpy(res_str, str1);
    strcat(res_str, str2);
    return res_str;
}

References loc_alloc().

make3_str()

char * make3_str	(	const char *	str1,
		const char *	str2,
		const char *	str3
	)

Definition at line 256 of file util.c.

{
    char       *res_str = (char *) loc_alloc(strlen(str1) + strlen(str2) + strlen(str3) + 1);
 
    strcpy(res_str, str1);
    strcat(res_str, str2);
    strcat(res_str, str3);
    return res_str;
}

References loc_alloc().

Referenced by filtered_base_yylex().

mm_alloc()

void * mm_alloc

(

size_t

size

)

Definition at line 85 of file util.c.

{
    void       *ptr = malloc(size);
 
    if (ptr == NULL)
        mmfatal(OUT_OF_MEMORY, "out of memory");
 
    return ptr;
}

References malloc, mmfatal(), OUT_OF_MEMORY, and size.

Referenced by add_descriptor(), add_include_path(), add_preprocessor_define(), add_variable_to_head(), add_variable_to_tail(), ECPGdump_a_simple(), ECPGdump_a_struct(), ECPGmake_simple_type(), ECPGmake_struct_member(), isdefine(), isinformixdefine(), lex_init(), loc_alloc(), main(), new_variable(), parse_include(), and push_assignment().

mm_strdup()

char * mm_strdup

(

const char *

string

)

Definition at line 97 of file util.c.

{
    char       *new = strdup(string);
 
    if (new == NULL)
        mmfatal(OUT_OF_MEMORY, "out of memory");
 
    return new;
}

References mmfatal(), and OUT_OF_MEMORY.

Referenced by add_descriptor(), add_preprocessor_define(), dump_variables(), ECPGdump_a_type(), ECPGmake_simple_type(), ECPGmake_struct_member(), ECPGmake_struct_type(), isdefine(), isinformixdefine(), lookup_descriptor(), main(), new_variable(), output_get_descr(), output_set_descr(), parse_include(), and push_assignment().

mmerror()

void mmerror	(	int	error_code,
		enum errortype	type,
		const char *	error,
			...
	)

Referenced by check_indicator(), drop_descriptor(), ECPGdump_a_struct(), ECPGdump_a_type(), ECPGfree_type(), ECPGnumeric_lvalue(), filtered_base_yylex(), get_dtype(), get_type(), lookup_descriptor(), main(), output_get_descr(), output_get_descr_header(), and output_set_descr_header().

mmfatal()

void void mmfatal	(	int	error_code,
		const char *	error,
			...
	)

Referenced by adjust_array(), ECPGdump_a_type(), find_struct(), find_struct_member(), find_variable(), get_typedef(), output_set_descr(), and parse_include().

new_variable()

struct variable * new_variable	(	const char *	name,
		struct ECPGtype *	type,
		int	brace_level
	)

Definition at line 10 of file variable.c.

{
    struct variable *p = (struct variable *) mm_alloc(sizeof(struct variable));
 
    p->name = mm_strdup(name);
    p->type = type;
    p->brace_level = brace_level;
 
    p->next = allvariables;
    allvariables = p;
 
    return p;
}

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

Referenced by find_struct_member(), and find_variable().

output_deallocate_prepare_statement()

void output_deallocate_prepare_statement

(

const char *

name

)

Definition at line 179 of file output.c.

{
    const char *con = connection ? connection : "NULL";
 
    if (strcmp(name, "all") != 0)
    {
        fprintf(base_yyout, "{ ECPGdeallocate(__LINE__, %d, %s, ", compat, con);
        output_escaped_str(name, true);
        fputs(");", base_yyout);
    }
    else
        fprintf(base_yyout, "{ ECPGdeallocate_all(__LINE__, %d, %s);", compat, con);
 
    whenever_action(2);
}

References base_yyout, compat, connection, fprintf, name, output_escaped_str(), and whenever_action().

output_get_descr()

void output_get_descr	(	const char *	desc_name,
		const char *	index
	)

Definition at line 175 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

(

const char *

desc_name

)

Definition at line 156 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_line_number()

void output_line_number

(

void

)

Definition at line 10 of file output.c.

{
    char       *line = hashline_number();
 
    fprintf(base_yyout, "%s", line);
}

References base_yyout, fprintf, and hashline_number().

Referenced by main(), output_simple_statement(), parse_include(), and whenever_action().

output_prepare_statement()

void output_prepare_statement	(	const char *	name,
		const char *	stmt
	)

Definition at line 168 of file output.c.

{
    fprintf(base_yyout, "{ ECPGprepare(__LINE__, %s, %d, ", connection ? connection : "NULL", questionmarks);
    output_escaped_str(name, true);
    fputs(", ", base_yyout);
    output_escaped_str(stmt, true);
    fputs(");", base_yyout);
    whenever_action(2);
}

References base_yyout, fprintf, name, output_escaped_str(), questionmarks, stmt, and whenever_action().

output_set_descr()

void output_set_descr	(	const char *	desc_name,
		const char *	index
	)

Definition at line 269 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

(

const char *

desc_name

)

Definition at line 208 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().

output_simple_statement()

void output_simple_statement	(	const char *	stmt,
		int	whenever_mode
	)

Definition at line 18 of file output.c.

{
    output_escaped_str(stmt, false);
    if (whenever_mode)
        whenever_action(whenever_mode);
    output_line_number();
}

References output_escaped_str(), output_line_number(), stmt, and whenever_action().

output_statement()

void output_statement	(	const char *	stmt,
		int	whenever_mode,
		enum ECPG_statement_type	st
	)

Definition at line 134 of file output.c.

{
    fprintf(base_yyout, "{ ECPGdo(__LINE__, %d, %d, %s, %d, ", compat, force_indicator, connection ? connection : "NULL", questionmarks);
 
    if (st == ECPGst_prepnormal && !auto_prepare)
        st = ECPGst_normal;
 
    /*
     * In following cases, stmt is CSTRING or char_variable. They must be
     * output directly. - prepared_name of EXECUTE without exprlist -
     * execstring of EXECUTE IMMEDIATE
     */
    fprintf(base_yyout, "%s, ", ecpg_statement_type_name[st]);
    if (st == ECPGst_execute || st == ECPGst_exec_immediate)
        fprintf(base_yyout, "%s, ", stmt);
    else
    {
        fputs("\"", base_yyout);
        output_escaped_str(stmt, false);
        fputs("\", ", base_yyout);
    }
 
    /* dump variables to C file */
    dump_variables(argsinsert, 1);
    argsinsert = NULL;
    fputs("ECPGt_EOIT, ", base_yyout);
    dump_variables(argsresult, 1);
    argsresult = NULL;
    fputs("ECPGt_EORT);", base_yyout);
 
    whenever_action(whenever_mode | 2);
}

References argsinsert, argsresult, auto_prepare, base_yyout, compat, dump_variables(), ecpg_statement_type_name, ECPGst_exec_immediate, ECPGst_execute, ECPGst_normal, ECPGst_prepnormal, force_indicator, fprintf, output_escaped_str(), questionmarks, stmt, and whenever_action().

parser_init()

void parser_init

(

void

)

pg_attribute_noreturn()

void void pg_attribute_noreturn

(

)

push_assignment()

void push_assignment	(	const 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_strdup(var);
    new->value = value;
    assignments = new;
}

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

reclaim_local_storage()

void reclaim_local_storage

(

void

)

Definition at line 182 of file util.c.

{
    loc_chunk  *cur_chunk,
               *next_chunk;
 
    for (cur_chunk = loc_chunks; cur_chunk; cur_chunk = next_chunk)
    {
        next_chunk = cur_chunk->next;
        free(cur_chunk);
    }
    loc_chunks = NULL;
}

References free, loc_chunks, and loc_chunk::next.

remove_typedefs()

void remove_typedefs

(

int

brace_level

)

Definition at line 264 of file variable.c.

{
    struct typedefs *p,
               *prev,
               *next;
 
    for (p = types, prev = NULL; p; p = next)
    {
        next = p->next;
        if (p->brace_level >= brace_level)
        {
            /* remove it */
            if (prev)
                prev->next = next;
            else
                types = next;
 
            if (p->type->type_enum == ECPGt_struct || p->type->type_enum == ECPGt_union)
                ECPGfree_struct_member(p->struct_member_list);
            free(p->type->type_storage);
            free(p->type->type_str);
            free(p->type->type_dimension);
            free(p->type->type_index);
            free(p->type->type_sizeof);
            free(p->type);
            free(p->name);
            free(p);
        }
        else
            prev = p;
    }
}

References typedefs::brace_level, ECPGfree_struct_member(), ECPGt_struct, ECPGt_union, free, typedefs::name, next, typedefs::next, typedefs::struct_member_list, typedefs::type, this_type::type_dimension, this_type::type_enum, this_type::type_index, this_type::type_sizeof, this_type::type_storage, this_type::type_str, and types.

remove_variable_from_list()

void remove_variable_from_list	(	struct arguments **	list,
		struct variable *	var
	)

Definition at line 431 of file variable.c.

{
    struct arguments *p,
               *prev = NULL;
    bool        found = false;
 
    for (p = *list; p; p = p->next)
    {
        if (p->variable == var)
        {
            found = true;
            break;
        }
        prev = p;
    }
    if (found)
    {
        if (prev)
            prev->next = p->next;
        else
            *list = p->next;
        free(p);
    }
}

References free, sort-test::list, arguments::next, and arguments::variable.

remove_variables()

void remove_variables

(

int

brace_level

)

Definition at line 298 of file variable.c.

{
    struct variable *p,
               *prev,
               *next;
 
    for (p = allvariables, prev = NULL; p; p = next)
    {
        next = p->next;
        if (p->brace_level >= brace_level)
        {
            /* remove it, but first remove any references from cursors */
            struct cursor *ptr;
 
            for (ptr = cur; ptr != NULL; ptr = ptr->next)
            {
                struct arguments *varptr,
                           *prevvar,
                           *nextvar;
 
                for (varptr = ptr->argsinsert, prevvar = NULL;
                     varptr != NULL; varptr = nextvar)
                {
                    nextvar = varptr->next;
                    if (p == varptr->variable)
                    {
                        /* remove from list */
                        if (prevvar)
                            prevvar->next = nextvar;
                        else
                            ptr->argsinsert = nextvar;
                        free(varptr);
                    }
                    else
                        prevvar = varptr;
                }
                for (varptr = ptr->argsresult, prevvar = NULL;
                     varptr != NULL; varptr = nextvar)
                {
                    nextvar = varptr->next;
                    if (p == varptr->variable)
                    {
                        /* remove from list */
                        if (prevvar)
                            prevvar->next = nextvar;
                        else
                            ptr->argsresult = nextvar;
                        free(varptr);
                    }
                    else
                        prevvar = varptr;
                }
            }
 
            /* remove it */
            if (prev)
                prev->next = next;
            else
                allvariables = next;
 
            ECPGfree_type(p->type);
            free(p->name);
            free(p);
        }
        else
            prev = p;
    }
}

References allvariables, cursor::argsinsert, cursor::argsresult, variable::brace_level, cur, ECPGfree_type(), free, variable::name, next, variable::next, cursor::next, arguments::next, variable::type, and arguments::variable.

reset_variables()

void reset_variables

(

void

)

Definition at line 378 of file variable.c.

{
    struct arguments *p,
               *next;
 
    for (p = argsinsert; p; p = next)
    {
        next = p->next;
        free(p);
    }
    argsinsert = NULL;
    for (p = argsresult; p; p = next)
    {
        next = p->next;
        free(p);
    }
    argsresult = NULL;
}

References argsinsert, argsresult, free, next, and arguments::next.

ScanCKeywordLookup()

int ScanCKeywordLookup

(

const char *

text

)

Definition at line 36 of file c_keywords.c.

{
    size_t      len;
    int         h;
    const char *kw;
 
    /*
     * Reject immediately if too long to be any keyword.  This saves useless
     * hashing work on long strings.
     */
    len = strlen(text);
    if (len > ScanCKeywords.max_kw_len)
        return -1;
 
    /*
     * Compute the hash function.  Since it's a perfect hash, we need only
     * match to the specific keyword it identifies.
     */
    h = ScanCKeywords_hash_func(text, len);
 
    /* An out-of-range result implies no match */
    if (h < 0 || h >= ScanCKeywords.num_keywords)
        return -1;
 
    kw = GetScanKeyword(h, &ScanCKeywords);
 
    if (strcmp(kw, text) == 0)
        return ScanCKeywordTokens[h];
 
    return -1;
}

References GetScanKeyword(), len, and ScanCKeywordTokens.

ScanECPGKeywordLookup()

int ScanECPGKeywordLookup

(

const char *

text

)

Definition at line 39 of file ecpg_keywords.c.

{
    int         kwnum;
 
    /* First check SQL symbols defined by the backend. */
    kwnum = ScanKeywordLookup(text, &ScanKeywords);
    if (kwnum >= 0)
        return SQLScanKeywordTokens[kwnum];
 
    /* Try ECPG-specific keywords. */
    kwnum = ScanKeywordLookup(text, &ScanECPGKeywords);
    if (kwnum >= 0)
        return ECPGScanKeywordTokens[kwnum];
 
    return -1;
}

References ECPGScanKeywordTokens, ScanKeywordLookup(), ScanKeywords, and SQLScanKeywordTokens.

sqlda_variable()

struct variable * sqlda_variable

(

const char *

name

)

Definition at line 345 of file descriptor.c.

{
    /*
     * 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;
}

References variable::brace_level, ECPGt_sqlda, loc_alloc(), loc_strdup(), name, variable::name, variable::next, and variable::type.

whenever_action()

void whenever_action

(

int

mode

)

Definition at line 64 of file output.c.

{
    if ((mode & 1) == 1 && when_nf.code != W_NOTHING)
    {
        output_line_number();
        fprintf(base_yyout, "\nif (sqlca.sqlcode == ECPG_NOT_FOUND) ");
        print_action(&when_nf);
    }
    if (when_warn.code != W_NOTHING)
    {
        output_line_number();
        fprintf(base_yyout, "\nif (sqlca.sqlwarn[0] == 'W') ");
        print_action(&when_warn);
    }
    if (when_error.code != W_NOTHING)
    {
        output_line_number();
        fprintf(base_yyout, "\nif (sqlca.sqlcode < 0) ");
        print_action(&when_error);
    }
 
    if ((mode & 2) == 2)
        fputc('}', base_yyout);
 
    output_line_number();
}

References base_yyout, when::code, fprintf, mode, output_line_number(), print_action(), W_NOTHING, and when_warn.

Referenced by output_deallocate_prepare_statement(), output_get_descr(), output_get_descr_header(), output_prepare_statement(), output_set_descr(), output_set_descr_header(), output_simple_statement(), and output_statement().

Variable Documentation

argsinsert

struct arguments* argsinsert

extern

Definition at line 374 of file variable.c.

Referenced by output_statement(), and reset_variables().

argsresult

struct arguments* argsresult

extern

Definition at line 375 of file variable.c.

Referenced by output_statement(), and reset_variables().

auto_create_c

bool auto_create_c

Definition at line 27 of file preproc_extern.h.

auto_prepare

bool auto_prepare

Definition at line 32 of file preproc_extern.h.

autocommit

bool autocommit

extern

Definition at line 15 of file ecpg.c.

Referenced by ECPGconnect(), and main().

base_yyin

FILE* base_yyin

extern

Referenced by main(), and mmfatal().

base_yylineno

int base_yylineno

extern

Referenced by hashline_number(), and vmmerror().

base_yyout

FILE * base_yyout

Definition at line 49 of file preproc_extern.h.

Referenced by dump_variables(), ECPGnumeric_lvalue(), main(), mmfatal(), output_deallocate_prepare_statement(), output_escaped_str(), output_get_descr(), output_get_descr_header(), output_line_number(), output_prepare_statement(), output_set_descr(), output_set_descr_header(), output_statement(), print_action(), and whenever_action().

base_yytext

char* base_yytext

extern

Referenced by base_yylex_location(), and filtered_base_yylex().

braces_open

int braces_open

extern

Referenced by lex_init().

compat

enum COMPAT_MODE compat

extern

Definition at line 26 of file ecpg.c.

Referenced by AddStmtToCache(), decompose_code(), ecpg_auto_prepare(), ecpg_build_compat_sqlda(), ecpg_build_native_sqlda(), ecpg_check_PQresult(), ecpg_do(), ecpg_do_prologue(), ecpg_freeStmtCacheEntry(), ecpg_get_data(), ecpg_raise_backend(), ecpg_set_compat_sqlda(), ecpg_set_native_sqlda(), ECPGconnect(), ECPGdeallocate_all(), ECPGdescribe(), ECPGdo(), garbage_left(), get_decomposed_size(), main(), output_deallocate_prepare_statement(), output_statement(), outzone(), parse_include(), sqlda_common_total_size(), sqlda_compat_total_size(), sqlda_dynamic_type(), sqlda_native_total_size(), stringrule(), stringzone(), and unicode_normalize().

connection

char* connection

extern

Referenced by AddStmtToCache(), and output_deallocate_prepare_statement().

cur

struct cursor* cur

extern

Definition at line 29 of file ecpg.c.

Referenced by _bt_advance_array_keys(), _bt_binsrch_array_skey(), _bt_compare_array_skey(), _bt_first(), _bt_preprocess_array_keys(), _bt_rewind_nonrequired_arrays(), _bt_tuple_before_array_skeys(), _hash_first(), addItemsToLeaf(), addToResult(), array_to_tsvector(), BeginCopyFrom(), BeginCopyTo(), count_spaces(), count_spaces_until(), create_range_bounds(), DoCopy(), DoCopyTo(), dsynonym_init(), executeNextItem(), fallbackSplit(), gbt_num_union(), gbt_var_picksplit(), gbt_var_union(), get_docrep(), gin_leafpage_items(), gist_box_union(), hashing(), IdentifySystem(), inet_net_ntop_ipv6(), IssuePendingWritebacks(), ltree_union(), main(), my_pv_display(), NextCopyFrom(), NextCopyFromRawFields(), NormalizeSubWord(), parse_lquery(), pg_current_snapshot(), pg_get_backend_memory_contexts(), pg_snapshot_recv(), pgstat_flush_pending_entries(), plainnode(), pqFreeCommandQueue(), printProgressReport(), PutMemoryContextsStatsTupleStore(), queryin(), read_dictionary(), remove_variables(), ReorderBufferRestoreCleanup(), slist_delete(), test_timing(), tsvector_strip(), tsvectorin(), vacuum(), and XmlTableGetValue().

current_function

char* current_function

extern

Referenced by lex_init().

defines

struct _defines* defines

extern

Definition at line 31 of file ecpg.c.

Referenced by add_preprocessor_define(), isdefine(), and main().

descriptor_name

char* descriptor_name

extern

ecpg_internal_var

int ecpg_internal_var

Definition at line 36 of file preproc_extern.h.

Referenced by main().

ecpg_no_indicator

struct ECPGtype ecpg_no_indicator

extern

Referenced by ECPGdump_a_struct().

force_indicator

bool force_indicator

Definition at line 29 of file preproc_extern.h.

g_declared_list

struct declared_list* g_declared_list

extern

Definition at line 32 of file ecpg.c.

Referenced by main().

include_paths

struct _include_path* include_paths

extern

Definition at line 28 of file ecpg.c.

Referenced by add_include_path(), main(), and parse_include().

input_filename

char* input_filename

extern

Referenced by hashline_number(), isdefine(), isinformixdefine(), main(), parse_include(), reconstruct_from_incremental_file(), vmmerror(), and write_reconstructed_file().

no_indicator

struct variable no_indicator

extern

output_filename

char* output_filename

extern

Definition at line 24 of file ecpg.c.

Referenced by main(), mmfatal(), reconstruct_from_incremental_file(), write_backup_label(), write_block(), and write_reconstructed_file().

questionmarks

bool questionmarks

Definition at line 30 of file preproc_extern.h.

regression_mode

bool regression_mode

Definition at line 31 of file preproc_extern.h.

ret_value

int ret_value

Definition at line 34 of file preproc_extern.h.

SQLScanKeywordTokens

const uint16 SQLScanKeywordTokens[]

extern

Definition at line 34 of file keywords.c.

Referenced by ScanECPGKeywordLookup().

struct_level

int struct_level

Definition at line 35 of file preproc_extern.h.

struct_member_list

struct ECPGstruct_member* struct_member_list[STRUCT_DEPTH]

extern

Referenced by main().

system_includes

bool system_includes

Definition at line 28 of file preproc_extern.h.

token_start

char * token_start

Definition at line 42 of file preproc_extern.h.

types

struct typedefs* types

extern

Definition at line 30 of file ecpg.c.

Referenced by BuildDescFromLists(), CreateStatistics(), extract_variadic_args(), get_typedef(), json_build_array(), json_build_array_worker(), json_build_object(), json_build_object_worker(), jsonb_build_array(), jsonb_build_array_worker(), jsonb_build_object(), jsonb_build_object_worker(), limitrange(), main(), PLy_procedure_create(), remove_typedefs(), stats_fill_fcinfo_from_arg_pairs(), and writezone().

when_warn

struct when when_error when_nf when_warn

extern

Definition at line 32 of file output.c.

Referenced by main(), and whenever_action().