pgc.l File Reference

#include "postgres_fe.h"
#include <ctype.h>
#include <limits.h>
#include "common/string.h"
#include "preproc_extern.h"
#include "preproc.h"

Include dependency graph for pgc.l:

Go to the source code of this file.

Data Structures
struct	_yy_buffer
struct	_if_value

Macros
#define	startlit()   (literalbuf[0] = '\0', literallen = 0)
#define	MAX_NESTED_IF   128

Functions
static void	addlit (char *ytext, int yleng)
static void	addlitchar (unsigned char ychar)
static int	process_integer_literal (const char *token, YYSTYPE *lval, int base)
static void	parse_include (void)
static bool	ecpg_isspace (char ch)
static bool	isdefine (void)
static bool	isinformixdefine (void)
int	yylex (void)
void	lex_init (void)

Variables
YYSTYPE	base_yylval
static int	xcdepth = 0
static char *	dolqstart = NULL
static char *	literalbuf = NULL
static int	literallen
static int	literalalloc
static int	parenths_open
static bool	include_next
char *	token_start
static int	state_before_str_start
static int	state_before_str_stop
static struct _yy_buffer *	yy_buffer = NULL
static short	preproc_tos
static bool	ifcond
static struct _if_value	stacked_if_value [MAX_NESTED_IF]

Macro Definition Documentation

MAX_NESTED_IF

#define MAX_NESTED_IF   128

Definition at line 102 of file pgc.l.

startlit

#define startlit

(

)

(literalbuf[0] = '\0', literallen = 0)

Definition at line 57 of file pgc.l.

Function Documentation

addlit()

static void addlit ( char *  ytext, int  yleng  )

static

Definition at line 1642 of file pgc.l.

{
    /* enlarge buffer if needed */
    if ((literallen + yleng) >= literalalloc)
    {
        do
            literalalloc *= 2;
        while ((literallen + yleng) >= literalalloc);
        literalbuf = (char *) realloc(literalbuf, literalalloc);
    }
    /* append new data, add trailing null */
    memcpy(literalbuf + literallen, ytext, yleng);
    literallen += yleng;
    literalbuf[literallen] = '\0';
}

References literalalloc, literalbuf, literallen, and realloc.

addlitchar()

static void addlitchar ( unsigned char  ychar )

static

Definition at line 1659 of file pgc.l.

{
    /* enlarge buffer if needed */
    if ((literallen + 1) >= literalalloc)
    {
        literalalloc *= 2;
        literalbuf = (char *) realloc(literalbuf, literalalloc);
    }
    /* append new data, add trailing null */
    literalbuf[literallen] = ychar;
    literallen += 1;
    literalbuf[literallen] = '\0';
}

References literalalloc, literalbuf, literallen, and realloc.

ecpg_isspace()

static bool ecpg_isspace ( char  ch )

static

Definition at line 1806 of file pgc.l.

{
    if (ch == ' ' ||
        ch == '\t' ||
        ch == '\n' ||
        ch == '\r' ||
        ch == '\f' ||
        ch == '\v')
        return true;
    return false;
}

Referenced by parse_include().

isdefine()

static bool isdefine ( void  )

static

Definition at line 1823 of file pgc.l.

{
    struct _defines *ptr;
 
    /* is it a define? */
    for (ptr = defines; ptr; ptr = ptr->next)
    {
        /* notice we do not match anything being actively expanded */
        if (strcmp(yytext, ptr->name) == 0 &&
            ptr->value != NULL &&
            ptr->used == NULL)
        {
            /* Save state associated with the current buffer */
            struct _yy_buffer *yb;
 
            yb = mm_alloc(sizeof(struct _yy_buffer));
 
            yb->buffer = YY_CURRENT_BUFFER;
            yb->lineno = yylineno;
            yb->filename = mm_strdup(input_filename);
            yb->next = yy_buffer;
            yy_buffer = yb;
 
            /* Mark symbol as being actively expanded */
            ptr->used = yb;
 
            /*
             * We use yy_scan_string which will copy the value, so there's no
             * need to worry about a possible undef happening while we are
             * still scanning it.
             */
            yy_scan_string(ptr->value);
            return true;
        }
    }
 
    return false;
}

References _yy_buffer::buffer, defines, _yy_buffer::filename, input_filename, _yy_buffer::lineno, mm_alloc(), mm_strdup(), _defines::name, _yy_buffer::next, _defines::next, _defines::used, _defines::value, and yy_buffer.

isinformixdefine()

static bool isinformixdefine ( void  )

static

Definition at line 1867 of file pgc.l.

{
    const char *new = NULL;
 
    if (strcmp(yytext, "dec_t") == 0)
        new = "decimal";
    else if (strcmp(yytext, "intrvl_t") == 0)
        new = "interval";
    else if (strcmp(yytext, "dtime_t") == 0)
        new = "timestamp";
 
    if (new)
    {
        struct _yy_buffer *yb;
 
        yb = mm_alloc(sizeof(struct _yy_buffer));
 
        yb->buffer = YY_CURRENT_BUFFER;
        yb->lineno = yylineno;
        yb->filename = mm_strdup(input_filename);
        yb->next = yy_buffer;
        yy_buffer = yb;
 
        yy_scan_string(new);
        return true;
    }
 
    return false;
}

References _yy_buffer::buffer, _yy_buffer::filename, input_filename, _yy_buffer::lineno, mm_alloc(), mm_strdup(), _yy_buffer::next, and yy_buffer.

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

parse_include()

static void parse_include ( void  )

static

Definition at line 1696 of file pgc.l.

{
    /* got the include file name */
    struct _yy_buffer *yb;
    struct _include_path *ip;
    char        inc_file[MAXPGPATH];
    unsigned int i;
 
    yb = mm_alloc(sizeof(struct _yy_buffer));
 
    yb->buffer = YY_CURRENT_BUFFER;
    yb->lineno = yylineno;
    yb->filename = input_filename;
    yb->next = yy_buffer;
 
    yy_buffer = yb;
 
    /*
     * skip the ";" if there is one and trailing whitespace. Note that yytext
     * contains at least one non-space character plus the ";"
     */
    for (i = strlen(yytext) - 2;
         i > 0 && ecpg_isspace(yytext[i]);
         i--)
        ;
 
    if (yytext[i] == ';')
        i--;
 
    yytext[i + 1] = '\0';
 
    yyin = NULL;
 
    /* If file name is enclosed in '"' remove these and look only in '.' */
 
    /*
     * Informix does look into all include paths though, except filename
     * starts with '/'
     */
    if (yytext[0] == '"' && yytext[i] == '"' &&
        ((compat != ECPG_COMPAT_INFORMIX && compat != ECPG_COMPAT_INFORMIX_SE) || yytext[1] == '/'))
    {
        yytext[i] = '\0';
        memmove(yytext, yytext + 1, strlen(yytext));
 
        strlcpy(inc_file, yytext, sizeof(inc_file));
        yyin = fopen(inc_file, "r");
        if (!yyin)
        {
            if (strlen(inc_file) <= 2 || strcmp(inc_file + strlen(inc_file) - 2, ".h") != 0)
            {
                strcat(inc_file, ".h");
                yyin = fopen(inc_file, "r");
            }
        }
 
    }
    else
    {
        if ((yytext[0] == '"' && yytext[i] == '"') || (yytext[0] == '<' && yytext[i] == '>'))
        {
            yytext[i] = '\0';
            memmove(yytext, yytext + 1, strlen(yytext));
        }
 
        for (ip = include_paths; yyin == NULL && ip != NULL; ip = ip->next)
        {
            if (strlen(ip->path) + strlen(yytext) + 4 > MAXPGPATH)
            {
                fprintf(stderr, _("Error: include path \"%s/%s\" is too long on line %d, skipping\n"), ip->path, yytext, yylineno);
                continue;
            }
            snprintf(inc_file, sizeof(inc_file), "%s/%s", ip->path, yytext);
            yyin = fopen(inc_file, "r");
            if (!yyin)
            {
                if (strcmp(inc_file + strlen(inc_file) - 2, ".h") != 0)
                {
                    strcat(inc_file, ".h");
                    yyin = fopen(inc_file, "r");
                }
            }
 
            /*
             * if the command was "include_next" we have to disregard the
             * first hit
             */
            if (yyin && include_next)
            {
                fclose(yyin);
                yyin = NULL;
                include_next = false;
            }
        }
    }
    if (!yyin)
        mmfatal(NO_INCLUDE_FILE, "could not open include file \"%s\" on line %d", yytext, yylineno);
 
    input_filename = mm_strdup(inc_file);
    yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
    yylineno = 1;
    output_line_number();
 
    BEGIN(C);
}

References _, _yy_buffer::buffer, compat, ECPG_COMPAT_INFORMIX, ECPG_COMPAT_INFORMIX_SE, ecpg_isspace(), _yy_buffer::filename, fprintf, i, include_next, include_paths, input_filename, _yy_buffer::lineno, MAXPGPATH, mm_alloc(), mm_strdup(), mmfatal(), _yy_buffer::next, _include_path::next, NO_INCLUDE_FILE, output_line_number(), _include_path::path, snprintf, strlcpy(), and yy_buffer.

process_integer_literal()

static int process_integer_literal ( const char *  token, YYSTYPE *  lval, int  base  )

static

Definition at line 1678 of file pgc.l.

{
    int         val;
    char       *endptr;
 
    errno = 0;
    val = strtoint(base == 10 ? token : token + 2, &endptr, base);
    if (*endptr != '\0' || errno == ERANGE)
    {
        /* integer too large (or contains decimal pt), treat it as a float */
        lval->str = loc_strdup(token);
        return FCONST;
    }
    lval->ival = val;
    return ICONST;
}

References loc_strdup(), strtoint(), and val.

yylex()

int yylex

(

void

)

Definition at line 463 of file pgc.l.

 {
        /* code to execute during start of each call of yylex() */
        char *newdefsymbol = NULL;
 
        token_start = NULL;
%}
 
<SQL>{
{whitespace}    {
                    /* ignore */
                }
} /* <SQL> */
 
<C,SQL>{
{xcstart}       {
                    token_start = yytext;
                    state_before_str_start = YYSTATE;
                    xcdepth = 0;
                    BEGIN(xc);
                    /* Put back any characters past slash-star; see above */
                    yyless(2);
                    fputs("/*", yyout);
                }
} /* <C,SQL> */
 
<xc>{
{xcstart}       {
                    if (state_before_str_start == SQL)
                    {
                        xcdepth++;
                        /* Put back any characters past slash-star; see above */
                        yyless(2);
                        fputs("/_*", yyout);
                    }
                    else if (state_before_str_start == C)
                    {
                        ECHO;
                    }
                }
 
{xcstop}        {
                    if (state_before_str_start == SQL)
                    {
                        if (xcdepth <= 0)
                        {
                            ECHO;
                            BEGIN(SQL);
                            token_start = NULL;
                        }
                        else
                        {
                            xcdepth--;
                            fputs("*_/", yyout);
                        }
                    }
                    else if (state_before_str_start == C)
                    {
                        ECHO;
                        BEGIN(C);
                        token_start = NULL;
                    }
                }
 
{xcinside}      {
                    ECHO;
                }
 
{op_chars}      {
                    ECHO;
                }
 
\*+             {
                    ECHO;
                }
 
<<EOF>>         {
                    mmfatal(PARSE_ERROR, "unterminated /* comment");
                }
} /* <xc> */
 
<SQL>{
{xbstart}       {
                    token_start = yytext;
                    state_before_str_start = YYSTATE;
                    BEGIN(xb);
                    startlit();
                }
} /* <SQL> */
 
<xh>{xhinside}  |
<xb>{xbinside}  {
                    addlit(yytext, yyleng);
                }
<xb><<EOF>>     {
                    mmfatal(PARSE_ERROR, "unterminated bit string literal");
                }
 
<SQL>{xhstart}  {
                    token_start = yytext;
                    state_before_str_start = YYSTATE;
                    BEGIN(xh);
                    startlit();
                }
<xh><<EOF>>     {
                    mmfatal(PARSE_ERROR, "unterminated hexadecimal string literal");
                }
 
<C>{xqstart}    {
                    token_start = yytext;
                    state_before_str_start = YYSTATE;
                    BEGIN(xqc);
                    startlit();
                }
 
<SQL>{
{xnstart}       {
                    /* National character. Transfer it as-is to the backend. */
                    token_start = yytext;
                    state_before_str_start = YYSTATE;
                    BEGIN(xn);
                    startlit();
                }
 
{xqstart}       {
                    token_start = yytext;
                    state_before_str_start = YYSTATE;
                    BEGIN(xq);
                    startlit();
                }
{xestart}       {
                    token_start = yytext;
                    state_before_str_start = YYSTATE;
                    BEGIN(xe);
                    startlit();
                }
{xusstart}      {
                    token_start = yytext;
                    state_before_str_start = YYSTATE;
                    BEGIN(xus);
                    startlit();
                }
} /* <SQL> */
 
<xb,xh,xq,xqc,xe,xn,xus>{quote} {
                    /*
                     * When we are scanning a quoted string and see an end
                     * quote, we must look ahead for a possible continuation.
                     * If we don't see one, we know the end quote was in fact
                     * the end of the string.  To reduce the lexer table size,
                     * we use a single "xqs" state to do the lookahead for all
                     * types of strings.
                     */
                    state_before_str_stop = YYSTATE;
                    BEGIN(xqs);
                }
<xqs>{quotecontinue} {
                    /*
                     * Found a quote continuation, so return to the in-quote
                     * state and continue scanning the literal.  Nothing is
                     * added to the literal's contents.
                     */
                    BEGIN(state_before_str_stop);
                }
<xqs>{quotecontinuefail} |
<xqs>{other} |
<xqs><<EOF>>    {
                    /*
                     * Failed to see a quote continuation.  Throw back
                     * everything after the end quote, and handle the string
                     * according to the state we were in previously.
                     */
                    yyless(0);
                    BEGIN(state_before_str_start);
 
                    switch (state_before_str_stop)
                    {
                        case xb:
                            if (literalbuf[strspn(literalbuf, "01")] != '\0')
                                mmerror(PARSE_ERROR, ET_ERROR, "invalid bit string literal");
                            base_yylval.str = make3_str("b'", literalbuf, "'");
                            return BCONST;
                        case xh:
                            if (literalbuf[strspn(literalbuf, "0123456789abcdefABCDEF")] != '\0')
                                mmerror(PARSE_ERROR, ET_ERROR, "invalid hexadecimal string literal");
                            base_yylval.str = make3_str("x'", literalbuf, "'");
                            return XCONST;
                        case xq:
                            /* fallthrough */
                        case xqc:
                            base_yylval.str = make3_str("'", literalbuf, "'");
                            return SCONST;
                        case xe:
                            base_yylval.str = make3_str("E'", literalbuf, "'");
                            return SCONST;
                        case xn:
                            base_yylval.str = make3_str("N'", literalbuf, "'");
                            return SCONST;
                        case xus:
                            base_yylval.str = make3_str("U&'", literalbuf, "'");
                            return USCONST;
                        default:
                            mmfatal(PARSE_ERROR, "unhandled previous state in xqs\n");
                    }
                }
 
<xq,xe,xn,xus>{xqdouble} {
                    addlit(yytext, yyleng);
                }
<xqc>{xqcquote} {
                    addlit(yytext, yyleng);
                }
<xq,xqc,xn,xus>{xqinside} {
                    addlit(yytext, yyleng);
                }
<xe>{xeinside}  {
                    addlit(yytext, yyleng);
                }
<xe>{xeunicode} {
                    addlit(yytext, yyleng);
                }
<xe>{xeescape}  {
                    addlit(yytext, yyleng);
                }
<xe>{xeoctesc}  {
                    addlit(yytext, yyleng);
                }
<xe>{xehexesc}  {
                    addlit(yytext, yyleng);
                }
<xe>.           {
                    /* This is only needed for \ just before EOF */
                    addlitchar(yytext[0]);
                }
<xq,xqc,xe,xn,xus><<EOF>>   {
                    mmfatal(PARSE_ERROR, "unterminated quoted string");
                }
 
<SQL>{
{dolqdelim}     {
                    token_start = yytext;
                    if (dolqstart)
                        free(dolqstart);
                    dolqstart = mm_strdup(yytext);
                    BEGIN(xdolq);
                    startlit();
                    addlit(yytext, yyleng);
                }
{dolqfailed}    {
                    /* throw back all but the initial "$" */
                    yyless(1);
                    /* and treat it as {other} */
                    return yytext[0];
                }
} /* <SQL> */
 
<xdolq>{dolqdelim}  {
                    if (strcmp(yytext, dolqstart) == 0)
                    {
                        addlit(yytext, yyleng);
                        free(dolqstart);
                        dolqstart = NULL;
                        BEGIN(SQL);
                        base_yylval.str = loc_strdup(literalbuf);
                        return SCONST;
                    }
                    else
                    {
                        /*
                         * When we fail to match $...$ to dolqstart, transfer
                         * the $... part to the output, but put back the final
                         * $ for rescanning.  Consider $delim$...$junk$delim$
                         */
                        addlit(yytext, yyleng - 1);
                        yyless(yyleng - 1);
                    }
                }
<xdolq>{dolqinside} {
                    addlit(yytext, yyleng);
                }
<xdolq>{dolqfailed} {
                    addlit(yytext, yyleng);
                }
<xdolq>.        {
                    /* single quote or dollar sign */
                    addlitchar(yytext[0]);
                }
<xdolq><<EOF>>  {
                    mmfatal(PARSE_ERROR, "unterminated dollar-quoted string");
                }
 
<SQL>{
{xdstart}       {
                    state_before_str_start = YYSTATE;
                    BEGIN(xd);
                    startlit();
                }
{xuistart}      {
                    state_before_str_start = YYSTATE;
                    BEGIN(xui);
                    startlit();
                }
} /* <SQL> */
 
<xd>{xdstop}    {
                    BEGIN(state_before_str_start);
                    if (literallen == 0)
                        mmerror(PARSE_ERROR, ET_ERROR, "zero-length delimited identifier");
 
                    /*
                     * The server will truncate the identifier here.  We do
                     * not, as (1) it does not change the result; (2) we don't
                     * know what NAMEDATALEN the server might use; (3) this
                     * code path is also taken for literal query strings in
                     * PREPARE and EXECUTE IMMEDIATE, which can certainly be
                     * longer than NAMEDATALEN.
                     */
                    base_yylval.str = loc_strdup(literalbuf);
                    return CSTRING;
                }
<xdc>{xdstop}   {
                    BEGIN(state_before_str_start);
                    base_yylval.str = loc_strdup(literalbuf);
                    return CSTRING;
                }
<xui>{dquote}   {
                    BEGIN(state_before_str_start);
                    if (literallen == 0)
                        mmerror(PARSE_ERROR, ET_ERROR, "zero-length delimited identifier");
 
                    /*
                     * The backend will truncate the identifier here. We do
                     * not as it does not change the result.
                     */
                    base_yylval.str = make3_str("U&\"", literalbuf, "\"");
                    return UIDENT;
                }
<xd,xui>{xddouble} {
                    addlit(yytext, yyleng);
                }
<xd,xui>{xdinside} {
                    addlit(yytext, yyleng);
                }
<xd,xui><<EOF>> {
                    mmfatal(PARSE_ERROR, "unterminated quoted identifier");
                }
<C>{xdstart}    {
                    state_before_str_start = YYSTATE;
                    BEGIN(xdc);
                    startlit();
                }
<xdc>{xdcinside} {
                    addlit(yytext, yyleng);
                }
<xdc><<EOF>>    {
                    mmfatal(PARSE_ERROR, "unterminated quoted string");
                }
 
<SQL>{
{typecast}      {
                    return TYPECAST;
                }
 
{dot_dot}       {
                    return DOT_DOT;
                }
 
{colon_equals}  {
                    return COLON_EQUALS;
                }
 
{equals_greater} {
                    return EQUALS_GREATER;
                }
 
{less_equals}   {
                    return LESS_EQUALS;
                }
 
{greater_equals} {
                    return GREATER_EQUALS;
                }
 
{less_greater}  {
                    /* We accept both "<>" and "!=" as meaning NOT_EQUALS */
                    return NOT_EQUALS;
                }
 
{not_equals}    {
                    /* We accept both "<>" and "!=" as meaning NOT_EQUALS */
                    return NOT_EQUALS;
                }
 
{informix_special} {
                    /* are we simulating Informix? */
                    if (INFORMIX_MODE)
                    {
                        unput(':');
                    }
                    else
                        return yytext[0];
                }
 
{self}          {
                    /*
                     * We may find a ';' inside a structure definition in a
                     * TYPE or VAR statement. This is not an EOL marker.
                     */
                    if (yytext[0] == ';' && struct_level == 0)
                        BEGIN(C);
                    return yytext[0];
                }
 
{operator}      {
                    /*
                     * Check for embedded slash-star or dash-dash; those
                     * are comment starts, so operator must stop there.
                     * Note that slash-star or dash-dash at the first
                     * character will match a prior rule, not this one.
                     */
                    int         nchars = yyleng;
                    char       *slashstar = strstr(yytext, "/*");
                    char       *dashdash = strstr(yytext, "--");
 
                    if (slashstar && dashdash)
                    {
                        /* if both appear, take the first one */
                        if (slashstar > dashdash)
                            slashstar = dashdash;
                    }
                    else if (!slashstar)
                        slashstar = dashdash;
                    if (slashstar)
                        nchars = slashstar - yytext;
 
                    /*
                     * For SQL compatibility, '+' and '-' cannot be the
                     * last char of a multi-char operator unless the operator
                     * contains chars that are not in SQL operators.
                     * The idea is to lex '=-' as two operators, but not
                     * to forbid operator names like '?-' that could not be
                     * sequences of SQL operators.
                     */
                    if (nchars > 1 &&
                        (yytext[nchars - 1] == '+' ||
                         yytext[nchars - 1] == '-'))
                    {
                        int         ic;
 
                        for (ic = nchars - 2; ic >= 0; ic--)
                        {
                            char        c = yytext[ic];
 
                            if (c == '~' || c == '!' || c == '@' ||
                                c == '#' || c == '^' || c == '&' ||
                                c == '|' || c == '`' || c == '?' ||
                                c == '%')
                                break;
                        }
                        if (ic < 0)
                        {
                            /*
                             * didn't find a qualifying character, so remove
                             * all trailing [+-]
                             */
                            do
                            {
                                nchars--;
                            } while (nchars > 1 &&
                                     (yytext[nchars - 1] == '+' ||
                                      yytext[nchars - 1] == '-'));
                        }
                    }
 
                    if (nchars < yyleng)
                    {
                        /* Strip the unwanted chars from the token */
                        yyless(nchars);
 
                        /*
                         * If what we have left is only one char, and it's
                         * one of the characters matching "self", then
                         * return it as a character token the same way
                         * that the "self" rule would have.
                         */
                        if (nchars == 1 &&
                            strchr(",()[].;:+-*/%^<>=", yytext[0]))
                            return yytext[0];
 
                        /*
                         * Likewise, if what we have left is two chars, and
                         * those match the tokens ">=", "<=", "=>", "<>" or
                         * "!=", then we must return the appropriate token
                         * rather than the generic Op.
                         */
                        if (nchars == 2)
                        {
                            if (yytext[0] == '=' && yytext[1] == '>')
                                return EQUALS_GREATER;
                            if (yytext[0] == '>' && yytext[1] == '=')
                                return GREATER_EQUALS;
                            if (yytext[0] == '<' && yytext[1] == '=')
                                return LESS_EQUALS;
                            if (yytext[0] == '<' && yytext[1] == '>')
                                return NOT_EQUALS;
                            if (yytext[0] == '!' && yytext[1] == '=')
                                return NOT_EQUALS;
                        }
                    }
 
                    base_yylval.str = loc_strdup(yytext);
                    return Op;
                }
 
{param}         {
                    int         val;
 
                    errno = 0;
                    val = strtoint(yytext + 1, NULL, 10);
                    if (errno == ERANGE)
                        mmfatal(PARSE_ERROR, "parameter number too large");
                    base_yylval.ival = val;
                    return PARAM;
                }
{param_junk}    {
                    mmfatal(PARSE_ERROR, "trailing junk after parameter");
                }
 
{ip}            {
                    base_yylval.str = loc_strdup(yytext);
                    return IP;
                }
}  /* <SQL> */
 
<C,SQL>{
{decinteger}    {
                    return process_integer_literal(yytext, &base_yylval, 10);
                }
{hexinteger}    {
                    return process_integer_literal(yytext, &base_yylval, 16);
                }
{numeric}       {
                    base_yylval.str = loc_strdup(yytext);
                    return FCONST;
                }
{numericfail}   {
                    /* throw back the .., and treat as integer */
                    yyless(yyleng - 2);
                    return process_integer_literal(yytext, &base_yylval, 10);
                }
{real}          {
                    base_yylval.str = loc_strdup(yytext);
                    return FCONST;
                }
{realfail}      {
                    /*
                     * throw back the [Ee][+-], and figure out whether what
                     * remains is an {decinteger} or {numeric}.
                     */
                    yyless(yyleng - 2);
                    return process_integer_literal(yytext, &base_yylval, 10);
                }
} /* <C,SQL> */
 
<SQL>{
{octinteger}    {
                    return process_integer_literal(yytext, &base_yylval, 8);
                }
{bininteger}    {
                    return process_integer_literal(yytext, &base_yylval, 2);
                }
 
    /*
     * Note that some trailing junk is valid in C (such as 100LL), so we
     * contain this to SQL mode.
     */
{integer_junk}  {
                    mmfatal(PARSE_ERROR, "trailing junk after numeric literal");
                }
{numeric_junk}  {
                    mmfatal(PARSE_ERROR, "trailing junk after numeric literal");
                }
{real_junk}     {
                    mmfatal(PARSE_ERROR, "trailing junk after numeric literal");
                }
 
:{identifier}((("->"|\.){identifier})|(\[{array}\]))*   {
                    base_yylval.str = loc_strdup(yytext + 1);
                    return CVARIABLE;
                }
 
{identifier}    {
                    /* First check to see if it's a define symbol to expand */
                    if (!isdefine())
                    {
                        int         kwvalue;
 
                        /*
                         * User-defined typedefs override SQL keywords, but
                         * not C keywords.  Currently, a typedef name is just
                         * reported as IDENT, but someday we might need to
                         * return a distinct token type.
                         */
                        if (get_typedef(yytext, true) == NULL)
                        {
                            /* Is it an SQL/ECPG keyword? */
                            kwvalue = ScanECPGKeywordLookup(yytext);
                            if (kwvalue >= 0)
                                return kwvalue;
                        }
 
                        /* Is it a C keyword? */
                        kwvalue = ScanCKeywordLookup(yytext);
                        if (kwvalue >= 0)
                            return kwvalue;
 
                        /*
                         * None of the above.  Return it as an identifier.
                         *
                         * The backend will attempt to truncate and case-fold
                         * the identifier, but I see no good reason for ecpg
                         * to do so; that's just another way that ecpg could
                         * get out of step with the backend.
                         */
                        base_yylval.str = loc_strdup(yytext);
                        return IDENT;
                    }
                }
 
{other}         {
                    return yytext[0];
                }
} /* <SQL> */
 
    /*
     * Begin ECPG-specific rules
     */
 
<C>{exec_sql}   {
                    BEGIN(SQL);
                    return SQL_START;
                }
<C>{informix_special}   {
                    /* are we simulating Informix? */
                    if (INFORMIX_MODE)
                    {
                        BEGIN(SQL);
                        return SQL_START;
                    }
                    else
                        return S_ANYTHING;
                }
<C>{ccomment}   {
                    ECHO;
                }
<C>{cppinclude} {
                    if (system_includes)
                    {
                        include_next = false;
                        BEGIN(incl);
                    }
                    else
                    {
                        base_yylval.str = loc_strdup(yytext);
                        return CPP_LINE;
                    }
                }
<C>{cppinclude_next} {
                    if (system_includes)
                    {
                        include_next = true;
                        BEGIN(incl);
                    }
                    else
                    {
                        base_yylval.str = loc_strdup(yytext);
                        return CPP_LINE;
                    }
                }
<C,SQL>{cppline} {
                    base_yylval.str = loc_strdup(yytext);
                    return CPP_LINE;
                }
<C>{identifier} {
                    /*
                     * Try to detect a function name:
                     * look for identifiers at the global scope
                     * keep the last identifier before the first '(' and '{'
                     */
                    if (braces_open == 0 && parenths_open == 0)
                    {
                        if (current_function)
                            free(current_function);
                        current_function = mm_strdup(yytext);
                    }
                    /* Informix uses SQL defines only in SQL space */
                    /* however, some defines have to be taken care of for compatibility */
                    if ((!INFORMIX_MODE || !isinformixdefine()) && !isdefine())
                    {
                        int         kwvalue;
 
                        kwvalue = ScanCKeywordLookup(yytext);
                        if (kwvalue >= 0)
                            return kwvalue;
                        else
                        {
                            base_yylval.str = loc_strdup(yytext);
                            return IDENT;
                        }
                    }
                }
<C>{xcstop}     {
                    mmerror(PARSE_ERROR, ET_ERROR, "nested /* ... */ comments");
                }
<C>":"              { return ':'; }
<C>";"              { return ';'; }
<C>","              { return ','; }
<C>"*"              { return '*'; }
<C>"%"              { return '%'; }
<C>"/"              { return '/'; }
<C>"+"              { return '+'; }
<C>"-"              { return '-'; }
<C>"("              { parenths_open++; return '('; }
<C>")"              { parenths_open--; return ')'; }
<C,xskip>{space}        { ECHO; }
<C>\{               { return '{'; }
<C>\}               { return '}'; }
<C>\[               { return '['; }
<C>\]               { return ']'; }
<C>\=               { return '='; }
<C>"->"             { return S_MEMBER; }
<C>">>"             { return S_RSHIFT; }
<C>"<<"             { return S_LSHIFT; }
<C>"||"             { return S_OR; }
<C>"&&"             { return S_AND; }
<C>"++"             { return S_INC; }
<C>"--"             { return S_DEC; }
<C>"=="             { return S_EQUAL; }
<C>"!="             { return S_NEQUAL; }
<C>"+="             { return S_ADD; }
<C>"-="             { return S_SUB; }
<C>"*="             { return S_MUL; }
<C>"/="             { return S_DIV; }
<C>"%="             { return S_MOD; }
<C>"->*"            { return S_MEMPOINT; }
<C>".*"             { return S_DOTPOINT; }
<C>{other}          { return S_ANYTHING; }
<C>{exec_sql}{define}{space}*   { BEGIN(def_ident); }
<C>{informix_special}{define}{space}*   {
                    /* are we simulating Informix? */
                    if (INFORMIX_MODE)
                    {
                        BEGIN(def_ident);
                    }
                    else
                    {
                        yyless(1);
                        return S_ANYTHING;
                    }
                }
<C>{exec_sql}{undef}{space}* {
                    BEGIN(undef);
                }
<C>{informix_special}{undef}{space}* {
                    /* are we simulating Informix? */
                    if (INFORMIX_MODE)
                    {
                        BEGIN(undef);
                    }
                    else
                    {
                        yyless(1);
                        return S_ANYTHING;
                    }
                }
<undef>{identifier}{space}*";" {
                    struct _defines *ptr,
                               *ptr2 = NULL;
                    int         i;
 
                    /*
                     * Skip the ";" and trailing whitespace. Note that yytext
                     * contains at least one non-space character plus the ";"
                     */
                    for (i = strlen(yytext) - 2;
                         i > 0 && ecpg_isspace(yytext[i]);
                         i--)
                        ;
                    yytext[i + 1] = '\0';
 
                    /* Find and unset any matching define; should be only 1 */
                    for (ptr = defines; ptr; ptr2 = ptr, ptr = ptr->next)
                    {
                        if (strcmp(yytext, ptr->name) == 0)
                        {
                            free(ptr->value);
                            ptr->value = NULL;
                            /* We cannot forget it if there's a cmdvalue */
                            if (ptr->cmdvalue == NULL)
                            {
                                if (ptr2 == NULL)
                                    defines = ptr->next;
                                else
                                    ptr2->next = ptr->next;
                                free(ptr->name);
                                free(ptr);
                            }
                            break;
                        }
                    }
 
                    BEGIN(C);
                }
<undef>{other}|\n {
                    mmfatal(PARSE_ERROR, "missing identifier in EXEC SQL UNDEF command");
                    yyterminate();
                }
<C>{exec_sql}{include}{space}* {
                    BEGIN(incl);
                }
<C>{informix_special}{include}{space}* {
                    /* are we simulating Informix? */
                    if (INFORMIX_MODE)
                    {
                        BEGIN(incl);
                    }
                    else
                    {
                        yyless(1);
                        return S_ANYTHING;
                    }
                }
<C,xskip>{exec_sql}{ifdef}{space}* {
                    if (preproc_tos >= MAX_NESTED_IF - 1)
                        mmfatal(PARSE_ERROR, "too many nested EXEC SQL IFDEF conditions");
                    preproc_tos++;
                    stacked_if_value[preproc_tos].active = false;
                    stacked_if_value[preproc_tos].saw_active = false;
                    stacked_if_value[preproc_tos].else_branch = false;
                    ifcond = true;
                    BEGIN(xcond);
                }
<C,xskip>{informix_special}{ifdef}{space}* {
                    /* are we simulating Informix? */
                    if (INFORMIX_MODE)
                    {
                        if (preproc_tos >= MAX_NESTED_IF - 1)
                            mmfatal(PARSE_ERROR, "too many nested EXEC SQL IFDEF conditions");
                        preproc_tos++;
                        stacked_if_value[preproc_tos].active = false;
                        stacked_if_value[preproc_tos].saw_active = false;
                        stacked_if_value[preproc_tos].else_branch = false;
                        ifcond = true;
                        BEGIN(xcond);
                    }
                    else
                    {
                        yyless(1);
                        return S_ANYTHING;
                    }
                }
<C,xskip>{exec_sql}{ifndef}{space}* {
                    if (preproc_tos >= MAX_NESTED_IF - 1)
                        mmfatal(PARSE_ERROR, "too many nested EXEC SQL IFDEF conditions");
                    preproc_tos++;
                    stacked_if_value[preproc_tos].active = false;
                    stacked_if_value[preproc_tos].saw_active = false;
                    stacked_if_value[preproc_tos].else_branch = false;
                    ifcond = false;
                    BEGIN(xcond);
                }
<C,xskip>{informix_special}{ifndef}{space}* {
                    /* are we simulating Informix? */
                    if (INFORMIX_MODE)
                    {
                        if (preproc_tos >= MAX_NESTED_IF - 1)
                            mmfatal(PARSE_ERROR, "too many nested EXEC SQL IFDEF conditions");
                        preproc_tos++;
                        stacked_if_value[preproc_tos].active = false;
                        stacked_if_value[preproc_tos].saw_active = false;
                        stacked_if_value[preproc_tos].else_branch = false;
                        ifcond = false;
                        BEGIN(xcond);
                    }
                    else
                    {
                        yyless(1);
                        return S_ANYTHING;
                    }
                }
<C,xskip>{exec_sql}{elif}{space}* {
                    if (preproc_tos == 0)
                        mmfatal(PARSE_ERROR, "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"");
                    if (stacked_if_value[preproc_tos].else_branch)
                        mmfatal(PARSE_ERROR, "missing \"EXEC SQL ENDIF;\"");
                    ifcond = true;
                    BEGIN(xcond);
                }
<C,xskip>{informix_special}{elif}{space}* {
                    /* are we simulating Informix? */
                    if (INFORMIX_MODE)
                    {
                        if (preproc_tos == 0)
                            mmfatal(PARSE_ERROR, "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"");
                        if (stacked_if_value[preproc_tos].else_branch)
                            mmfatal(PARSE_ERROR, "missing \"EXEC SQL ENDIF;\"");
                        ifcond = true;
                        BEGIN(xcond);
                    }
                    else
                    {
                        yyless(1);
                        return S_ANYTHING;
                    }
                }
 
<C,xskip>{exec_sql}{else}{space}*";" {
    /* only exec sql endif pops the stack, so take care of duplicated 'else' */
                    if (preproc_tos == 0)
                        mmfatal(PARSE_ERROR, "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"");
                    else if (stacked_if_value[preproc_tos].else_branch)
                        mmfatal(PARSE_ERROR, "more than one EXEC SQL ELSE");
                    else
                    {
                        stacked_if_value[preproc_tos].else_branch = true;
                        stacked_if_value[preproc_tos].active =
                            (stacked_if_value[preproc_tos - 1].active &&
                             !stacked_if_value[preproc_tos].saw_active);
                        stacked_if_value[preproc_tos].saw_active = true;
 
                        if (stacked_if_value[preproc_tos].active)
                            BEGIN(C);
                        else
                            BEGIN(xskip);
                    }
                }
<C,xskip>{informix_special}{else}{space}*";" {
                    /* are we simulating Informix? */
                    if (INFORMIX_MODE)
                    {
                        if (preproc_tos == 0)
                            mmfatal(PARSE_ERROR, "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"");
                        else if (stacked_if_value[preproc_tos].else_branch)
                            mmfatal(PARSE_ERROR, "more than one EXEC SQL ELSE");
                        else
                        {
                            stacked_if_value[preproc_tos].else_branch = true;
                            stacked_if_value[preproc_tos].active =
                                (stacked_if_value[preproc_tos - 1].active &&
                                 !stacked_if_value[preproc_tos].saw_active);
                            stacked_if_value[preproc_tos].saw_active = true;
 
                            if (stacked_if_value[preproc_tos].active)
                                BEGIN(C);
                            else
                                BEGIN(xskip);
                        }
                    }
                    else
                    {
                        yyless(1);
                        return S_ANYTHING;
                    }
                }
<C,xskip>{exec_sql}{endif}{space}*";" {
                    if (preproc_tos == 0)
                        mmfatal(PARSE_ERROR, "unmatched EXEC SQL ENDIF");
                    else
                        preproc_tos--;
 
                    if (stacked_if_value[preproc_tos].active)
                        BEGIN(C);
                    else
                        BEGIN(xskip);
                }
<C,xskip>{informix_special}{endif}{space}*";" {
                    /* are we simulating Informix? */
                    if (INFORMIX_MODE)
                    {
                        if (preproc_tos == 0)
                            mmfatal(PARSE_ERROR, "unmatched EXEC SQL ENDIF");
                        else
                            preproc_tos--;
 
                        if (stacked_if_value[preproc_tos].active)
                            BEGIN(C);
                        else
                            BEGIN(xskip);
                    }
                    else
                    {
                        yyless(1);
                        return S_ANYTHING;
                    }
                }
 
<xskip>{other}  { /* ignore */ }
 
<xcond>{identifier}{space}*";" {
                    {
                        struct _defines *defptr;
                        unsigned int i;
                        bool        this_active;
 
                        /*
                         * Skip the ";" and trailing whitespace. Note that
                         * yytext contains at least one non-space character
                         * plus the ";"
                         */
                        for (i = strlen(yytext) - 2;
                             i > 0 && ecpg_isspace(yytext[i]);
                             i--)
                            /* skip */ ;
                        yytext[i + 1] = '\0';
 
                        /* Does a definition exist? */
                        for (defptr = defines; defptr; defptr = defptr->next)
                        {
                            if (strcmp(yytext, defptr->name) == 0)
                            {
                                /* Found it, but is it currently undefined? */
                                if (defptr->value == NULL)
                                    defptr = NULL; /* pretend it's not found */
                                break;
                            }
                        }
 
                        this_active = (defptr ? ifcond : !ifcond);
                        stacked_if_value[preproc_tos].active =
                            (stacked_if_value[preproc_tos - 1].active &&
                             !stacked_if_value[preproc_tos].saw_active &&
                             this_active);
                        stacked_if_value[preproc_tos].saw_active |= this_active;
                    }
 
                    if (stacked_if_value[preproc_tos].active)
                        BEGIN(C);
                    else
                        BEGIN(xskip);
                }
 
<xcond>{other}|\n {
                    mmfatal(PARSE_ERROR, "missing identifier in EXEC SQL IFDEF command");
                    yyterminate();
                }
<def_ident>{identifier} {
                    newdefsymbol = mm_strdup(yytext);
                    BEGIN(def);
                    startlit();
                }
<def_ident>{other}|\n {
                    mmfatal(PARSE_ERROR, "missing identifier in EXEC SQL DEFINE command");
                    yyterminate();
                }
<def>{space}*";" {
                    struct _defines *ptr;
 
                    /* Does it already exist? */
                    for (ptr = defines; ptr != NULL; ptr = ptr->next)
                    {
                        if (strcmp(newdefsymbol, ptr->name) == 0)
                        {
                            free(ptr->value);
                            ptr->value = mm_strdup(literalbuf);
                            /* Don't leak newdefsymbol */
                            free(newdefsymbol);
                            break;
                        }
                    }
                    if (ptr == NULL)
                    {
                        /* Not present, make a new entry */
                        ptr = (struct _defines *) mm_alloc(sizeof(struct _defines));
 
                        ptr->name = newdefsymbol;
                        ptr->value = mm_strdup(literalbuf);
                        ptr->cmdvalue = NULL;
                        ptr->used = NULL;
                        ptr->next = defines;
                        defines = ptr;
                    }
 
                    BEGIN(C);
                }
<def>[^;]       { addlit(yytext, yyleng); }
<incl><[^>]+>{space}*";"?   {   parse_include(); }
<incl>{dquote}{xdinside}{dquote}{space}*";"?    {   parse_include(); }
<incl>[^;<>\"]+";"  { parse_include(); }
<incl>{other}|\n {
                    mmfatal(PARSE_ERROR, "syntax error in EXEC SQL INCLUDE command");
                    yyterminate();
                }
 
<<EOF>>         {
                    if (yy_buffer == NULL)
                    {
                        /* No more input */
                        if (preproc_tos > 0)
                        {
                            preproc_tos = 0;
                            mmfatal(PARSE_ERROR, "missing \"EXEC SQL ENDIF;\"");
                        }
                        yyterminate();
                    }
                    else
                    {
                        /* Revert to previous input source */
                        struct _yy_buffer *yb = yy_buffer;
                        int         i;
                        struct _defines *ptr;
 
                        /* Check to see if we are exiting a macro value */
                        for (ptr = defines; ptr; ptr = ptr->next)
                        {
                            if (ptr->used == yy_buffer)
                            {
                                ptr->used = NULL;
                                break; /* there can't be multiple matches */
                            }
                        }
 
                        if (yyin != NULL)
                            fclose(yyin);
 
                        yy_delete_buffer(YY_CURRENT_BUFFER);
                        yy_switch_to_buffer(yy_buffer->buffer);
 
                        yylineno = yy_buffer->lineno;
 
                        /* We have to output the filename only if we change files here */
                        i = strcmp(input_filename, yy_buffer->filename);
 
                        free(input_filename);
                        input_filename = yy_buffer->filename;
 
                        yy_buffer = yy_buffer->next;
                        free(yb);
 
                        if (i != 0)
                            output_line_number();
                    }
                }
 
<INITIAL>{other}|\n {
                    mmfatal(PARSE_ERROR, "internal error: unreachable state; please report this to <%s>", PACKAGE_BUGREPORT);
                }
 
%%

Variable Documentation

base_yylval

YYSTYPE base_yylval

extern

Referenced by base_yylex_location(), and filtered_base_yylex().

dolqstart

char* dolqstart = NULL

static

Definition at line 39 of file pgc.l.

ifcond

bool ifcond

static

Definition at line 104 of file pgc.l.

include_next

bool include_next

static

Definition at line 55 of file pgc.l.

Referenced by parse_include().

literalalloc

int literalalloc

static

Definition at line 49 of file pgc.l.

Referenced by addlit(), addlitchar(), and lex_init().

literalbuf

char* literalbuf = NULL

static

Definition at line 47 of file pgc.l.

Referenced by addlit(), addlitchar(), and lex_init().

literallen

int literallen

static

Definition at line 48 of file pgc.l.

Referenced by addlit(), and addlitchar().

parenths_open

int parenths_open

static

Definition at line 52 of file pgc.l.

Referenced by lex_init().

preproc_tos

short preproc_tos

static

Definition at line 103 of file pgc.l.

Referenced by lex_init().

stacked_if_value

struct _if_value stacked_if_value[MAX_NESTED_IF]

static

Referenced by lex_init().

state_before_str_start

int state_before_str_start

static

Definition at line 69 of file pgc.l.

state_before_str_stop

int state_before_str_stop

static

Definition at line 70 of file pgc.l.

token_start

char* token_start

Definition at line 66 of file pgc.l.

xcdepth

int xcdepth = 0

static

Definition at line 38 of file pgc.l.

yy_buffer

struct _yy_buffer * yy_buffer = NULL

static

Referenced by isdefine(), isinformixdefine(), and parse_include().