output.c File Reference

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

Include dependency graph for output.c:

Go to the source code of this file.

Functions
static void	output_escaped_str (char *str, bool quoted)
void	output_line_number (void)
void	output_simple_statement (char *stmt, int whenever_mode)
static void	print_action (struct when *w)
void	whenever_action (int mode)
char *	hashline_number (void)
void	output_statement (char *stmt, int whenever_mode, enum ECPG_statement_type st)
void	output_prepare_statement (char *name, char *stmt)
void	output_deallocate_prepare_statement (char *name)

Variables
struct when when_error when_nf	when_warn
static char *	ecpg_statement_type_name []

Function Documentation

hashline_number()

char* hashline_number

(

void

)

Definition at line 94 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 = mm_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 EMPTY;
}

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

Referenced by output_line_number().

output_deallocate_prepare_statement()

void output_deallocate_prepare_statement

(

char *

name

)

Definition at line 182 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);
    free(name);
}

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

output_escaped_str()

static void output_escaped_str ( char *  str, bool  quoted  )

static

Definition at line 200 of file output.c.

{
    int         i = 0;
    int         len = strlen(str);
 
    if (quoted && str[0] == '"' && str[len - 1] == '"') /* do not escape quotes
                                                         * at beginning and end
                                                         * if quoted string */
    {
        i = 1;
        len--;
        fputs("\"", base_yyout);
    }
 
    /* output this char by char as we have to filter " and \n */
    for (; i < len; i++)
    {
        if (str[i] == '"')
            fputs("\\\"", base_yyout);
        else if (str[i] == '\n')
            fputs("\\\n", base_yyout);
        else if (str[i] == '\\')
        {
            int         j = i;
 
            /*
             * check whether this is a continuation line if it is, do not
             * output anything because newlines are escaped anyway
             */
 
            /* accept blanks after the '\' as some other compilers do too */
            do
            {
                j++;
            } while (str[j] == ' ' || str[j] == '\t');
 
            if ((str[j] != '\n') && (str[j] != '\r' || str[j + 1] != '\n')) /* not followed by a
                                                                             * newline */
                fputs("\\\\", base_yyout);
        }
        else if (str[i] == '\r' && str[i + 1] == '\n')
        {
            fputs("\\\r\n", base_yyout);
            i++;
        }
        else
            fputc(str[i], base_yyout);
    }
 
    if (quoted && str[0] == '"' && str[len] == '"')
        fputs("\"", base_yyout);
}

References base_yyout, i, j, len, and str.

Referenced by output_deallocate_prepare_statement(), output_prepare_statement(), output_simple_statement(), and output_statement().

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);
    free(line);
}

References base_yyout, fprintf, free, and hashline_number().

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

output_prepare_statement()

void output_prepare_statement	(	char *	name,
		char *	stmt
	)

Definition at line 170 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);
    free(name);
}

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

output_simple_statement()

void output_simple_statement	(	char *	stmt,
		int	whenever_mode
	)

Definition at line 19 of file output.c.

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

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

output_statement()

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

Definition at line 136 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);
    fputs("ECPGt_EOIT, ", base_yyout);
    dump_variables(argsresult, 1);
    fputs("ECPGt_EORT);", base_yyout);
    reset_variables();
 
    whenever_action(whenever_mode | 2);
    free(stmt);
}

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, free, output_escaped_str(), questionmarks, reset_variables(), stmt, and whenever_action().

print_action()

static void print_action ( struct when *  w )

static

Definition at line 37 of file output.c.

{
    switch (w->code)
    {
        case W_SQLPRINT:
            fprintf(base_yyout, "sqlprint();");
            break;
        case W_GOTO:
            fprintf(base_yyout, "goto %s;", w->command);
            break;
        case W_DO:
            fprintf(base_yyout, "%s;", w->command);
            break;
        case W_STOP:
            fprintf(base_yyout, "exit (1);");
            break;
        case W_BREAK:
            fprintf(base_yyout, "break;");
            break;
        case W_CONTINUE:
            fprintf(base_yyout, "continue;");
            break;
        default:
            fprintf(base_yyout, "{/* %d not implemented yet */}", w->code);
            break;
    }
}

References base_yyout, when::code, when::command, fprintf, W_BREAK, W_CONTINUE, W_DO, W_GOTO, W_SQLPRINT, and W_STOP.

Referenced by whenever_action().

whenever_action()

void whenever_action

(

int

mode

)

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

ecpg_statement_type_name

char* ecpg_statement_type_name[]

static

Initial value:

= {
    "ECPGst_normal",
    "ECPGst_execute",
    "ECPGst_exec_immediate",
    "ECPGst_prepnormal",
    "ECPGst_prepare",
    "ECPGst_exec_with_exprlist"
}

Definition at line 126 of file output.c.

Referenced by output_statement().

when_warn

struct when when_error when_nf when_warn

Definition at line 19 of file output.c.

Referenced by main(), and whenever_action().