pgc.l

Go to the documentation of this file.

%top{
/*-------------------------------------------------------------------------
 *
 * pgc.l
 *    lexical scanner for ecpg
 *
 * This is a modified version of src/backend/parser/scan.l
 *
 * The ecpg scanner is not backup-free, so the fail rules are
 * only here to simplify syncing this file with scan.l.
 *
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *    src/interfaces/ecpg/preproc/pgc.l
 *
 *-------------------------------------------------------------------------
 */
#include "postgres_fe.h"
 
#include <ctype.h>
#include <limits.h>
 
#include "common/string.h"
 
#include "preproc_extern.h"
#include "preproc.h"
}
 
%{
 
/* LCOV_EXCL_START */
 
extern YYSTYPE base_yylval;
 
static int  xcdepth = 0;        /* depth of nesting in slash-star comments */
static char *dolqstart = NULL;  /* current $foo$ quote start string */
 
/*
 * literalbuf is used to accumulate literal values when multiple rules
 * are needed to parse a single literal.  Call startlit to reset buffer
 * to empty, addlit to add text.  Note that the buffer is permanently
 * malloc'd to the largest size needed so far in the current run.
 */
static char *literalbuf = NULL; /* expandable buffer */
static int  literallen;         /* actual current length */
static int  literalalloc;       /* current allocated buffer size */
 
/* Used for detecting global state together with braces_open */
static int  parenths_open;
 
/* Used to tell parse_include() whether the command was #include or #include_next */
static bool include_next;
 
#define startlit()  (literalbuf[0] = '\0', literallen = 0)
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);
 
char       *token_start;
 
/* vars to keep track of start conditions when scanning literals */
static int  state_before_str_start;
static int  state_before_str_stop;
 
/*
 * State for handling include files and macro expansion.  We use a new
 * flex input buffer for each level of include or macro, and create a
 * struct _yy_buffer to remember the previous level.  There is not a struct
 * for the currently active input source; that state is kept in the global
 * variables YY_CURRENT_BUFFER, yylineno, and input_filename.
 */
static struct _yy_buffer
{
    YY_BUFFER_STATE buffer;
    long        lineno;
    char       *filename;
    struct _yy_buffer *next;
} *yy_buffer = NULL;
 
/*
 * Vars for handling ifdef/elif/endif constructs.  preproc_tos is the current
 * nesting depth of such constructs, and stacked_if_value[preproc_tos] is the
 * state for the innermost level.  (For convenience, stacked_if_value[0] is
 * initialized as though we are in the active branch of some outermost IF.)
 * The active field is true if the current branch is active (being expanded).
 * The saw_active field is true if we have found any successful branch,
 * so that all subsequent branches of this level should be skipped.
 * The else_branch field is true if we've found an 'else' (so that another
 * 'else' or 'elif' at this level is an error.)
 * For IFs nested within an inactive branch, all branches always have active
 * set to false, but saw_active and else_branch are maintained normally.
 * ifcond is valid only while evaluating an if-condition; it's true if we
 * are doing ifdef, false if ifndef.
 */
#define MAX_NESTED_IF 128
static short preproc_tos;
static bool ifcond;
static struct _if_value
{
    bool        active;
    bool        saw_active;
    bool        else_branch;
} stacked_if_value[MAX_NESTED_IF];
 
%}
 
%option 8bit
%option never-interactive
%option nodefault
%option noinput
%option noyywrap
%option warn
%option yylineno
%option prefix="base_yy"
 
/*
 * OK, here is a short description of lex/flex rules behavior.
 * The longest pattern which matches an input string is always chosen.
 * For equal-length patterns, the first occurring in the rules list is chosen.
 * INITIAL is the starting state, to which all non-conditional rules apply.
 * Exclusive states change parsing rules while the state is active.  When in
 * an exclusive state, only those rules defined for that state apply.
 *
 * We use exclusive states for quoted strings, extended comments,
 * and to eliminate parsing troubles for numeric strings.
 * Exclusive states:
 *  <xb> bit string literal
 *  <xc> extended C-style comments
 *  <xd> delimited identifiers (double-quoted identifiers)
 *  <xdc> double-quoted strings in C
 *  <xh> hexadecimal byte string
 *  <xn> national character quoted strings
 *  <xq> standard quoted strings
 *  <xqs> quote stop (detect continued strings)
 *  <xe> extended quoted strings (support backslash escape sequences)
 *  <xqc> single-quoted strings in C
 *  <xdolq> $foo$ quoted strings
 *  <xui> quoted identifier with Unicode escapes
 *  <xus> quoted string with Unicode escapes
 *  <xcond> condition of an EXEC SQL IFDEF construct
 *  <xskip> skipping the inactive part of an EXEC SQL IFDEF construct
 *
 * Note: we intentionally don't mimic the backend's <xeu> state; we have
 * no need to distinguish it from <xe> state.
 *
 * Remember to add an <<EOF>> case whenever you add a new exclusive state!
 * The default one is probably not the right thing.
 */
 
%x xb
%x xc
%x xd
%x xdc
%x xh
%x xn
%x xq
%x xqs
%x xe
%x xqc
%x xdolq
%x xui
%x xus
%x xcond
%x xskip
 
/* Additional exclusive states that are specific to ECPG */
%x C SQL incl def def_ident undef
 
/*
 * In order to make the world safe for Windows and Mac clients as well as
 * Unix ones, we accept either \n or \r as a newline.  A DOS-style \r\n
 * sequence will be seen as two successive newlines, but that doesn't cause
 * any problems.  SQL-style comments, which start with -- and extend to the
 * next newline, are treated as equivalent to a single whitespace character.
 *
 * NOTE a fine point: if there is no newline following --, we will absorb
 * everything to the end of the input as a comment.  This is correct.  Older
 * versions of Postgres failed to recognize -- as a comment if the input
 * did not end with a newline.
 *
 * non_newline_space tracks all space characters except newlines.
 *
 * XXX if you change the set of whitespace characters, fix ecpg_isspace()
 * to agree.
 */
 
space               [ \t\n\r\f\v]
non_newline_space   [ \t\f\v]
newline             [\n\r]
non_newline         [^\n\r]
 
comment         ("--"{non_newline}*)
 
whitespace      ({space}+|{comment})
 
/*
 * SQL requires at least one newline in the whitespace separating
 * string literals that are to be concatenated.  Silly, but who are we
 * to argue?  Note that {whitespace_with_newline} should not have * after
 * it, whereas {whitespace} should generally have a * after it...
 */
 
non_newline_whitespace  ({non_newline_space}|{comment})
whitespace_with_newline ({non_newline_whitespace}*{newline}{whitespace}*)
 
quote           '
/* If we see {quote} then {quotecontinue}, the quoted string continues */
quotecontinue   {whitespace_with_newline}{quote}
 
/*
 * {quotecontinuefail} is needed to avoid lexer backup when we fail to match
 * {quotecontinue}.  It might seem that this could just be {whitespace}*,
 * but if there's a dash after {whitespace_with_newline}, it must be consumed
 * to see if there's another dash --- which would start a {comment} and thus
 * allow continuation of the {quotecontinue} token.
 */
quotecontinuefail   {whitespace}*"-"?
 
/* Bit string
 */
xbstart         [bB]{quote}
xbinside        [^']*
 
/* Hexadecimal byte string */
xhstart         [xX]{quote}
xhinside        [^']*
 
/* National character */
xnstart         [nN]{quote}
 
/* Quoted string that allows backslash escapes */
xestart         [eE]{quote}
xeinside        [^\\']+
xeescape        [\\][^0-7]
xeoctesc        [\\][0-7]{1,3}
xehexesc        [\\]x[0-9A-Fa-f]{1,2}
xeunicode       [\\](u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})
 
/* Extended quote
 * xqdouble implements embedded quote, ''''
 */
xqstart         {quote}
xqdouble        {quote}{quote}
xqcquote        [\\]{quote}
xqinside        [^']+
 
/* $foo$ style quotes ("dollar quoting")
 * The quoted string starts with $foo$ where "foo" is an optional string
 * in the form of an identifier, except that it may not contain "$",
 * and extends to the first occurrence of an identical string.
 * There is *no* processing of the quoted text.
 *
 * {dolqfailed} is an error rule to avoid scanner backup when {dolqdelim}
 * fails to match its trailing "$".
 */
dolq_start      [A-Za-z\200-\377_]
dolq_cont       [A-Za-z\200-\377_0-9]
dolqdelim       \$({dolq_start}{dolq_cont}*)?\$
dolqfailed      \${dolq_start}{dolq_cont}*
dolqinside      [^$]+
 
/* Double quote
 * Allows embedded spaces and other special characters into identifiers.
 */
dquote          \"
xdstart         {dquote}
xdstop          {dquote}
xddouble        {dquote}{dquote}
xdinside        [^"]+
 
/* Quoted identifier with Unicode escapes */
xuistart        [uU]&{dquote}
 
/* Quoted string with Unicode escapes */
xusstart        [uU]&{quote}
 
/* special stuff for C strings */
xdcqq           \\\\
xdcqdq          \\\"
xdcother        [^"]
xdcinside       ({xdcqq}|{xdcqdq}|{xdcother})
 
 
/* C-style comments
 *
 * The "extended comment" syntax closely resembles allowable operator syntax.
 * The tricky part here is to get lex to recognize a string starting with
 * slash-star as a comment, when interpreting it as an operator would produce
 * a longer match --- remember lex will prefer a longer match!  Also, if we
 * have something like plus-slash-star, lex will think this is a 3-character
 * operator whereas we want to see it as a + operator and a comment start.
 * The solution is two-fold:
 * 1. append {op_chars}* to xcstart so that it matches as much text as
 *    {operator} would. Then the tie-breaker (first matching rule of same
 *    length) ensures xcstart wins.  We put back the extra stuff with yyless()
 *    in case it contains a star-slash that should terminate the comment.
 * 2. In the operator rule, check for slash-star within the operator, and
 *    if found throw it back with yyless().  This handles the plus-slash-star
 *    problem.
 * Dash-dash comments have similar interactions with the operator rule.
 */
xcstart         \/\*{op_chars}*
xcstop          \*+\/
xcinside        [^*/]+
 
ident_start     [A-Za-z\200-\377_]
ident_cont      [A-Za-z\200-\377_0-9\$]
 
identifier      {ident_start}{ident_cont}*
 
array           ({ident_cont}|{whitespace}|[\[\]\+\-\*\%\/\‍(\‍)>\.])*
 
/* Assorted special-case operators and operator-like tokens */
typecast        "::"
dot_dot         \.\.
colon_equals    ":="
 
/*
 * These operator-like tokens (unlike the above ones) also match the {operator}
 * rule, which means that they might be overridden by a longer match if they
 * are followed by a comment start or a + or - character. Accordingly, if you
 * add to this list, you must also add corresponding code to the {operator}
 * block to return the correct token in such cases. (This is not needed in
 * psqlscan.l since the token value is ignored there.)
 */
equals_greater  "=>"
less_equals     "<="
greater_equals  ">="
less_greater    "<>"
not_equals      "!="
/* Note there is no need for left_arrow, since "<-" is not a single operator. */
right_arrow     "->"
 
/*
 * "self" is the set of chars that should be returned as single-character
 * tokens.  "op_chars" is the set of chars that can make up "Op" tokens,
 * which can be one or more characters long (but if a single-char token
 * appears in the "self" set, it is not to be returned as an Op).  Note
 * that the sets overlap, but each has some chars that are not in the other.
 *
 * If you change either set, adjust the character lists appearing in the
 * rule for "operator"!
 */
self            [,()\[\].;\:\|\+\-\*\/\%\^<>\=]
op_chars        [\~\!\@\#\^\&\|\`\?\+\-\*\/\%<>\=]
operator        {op_chars}+
 
/*
 * Numbers
 *
 * Unary minus is not part of a number here.  Instead we pass it separately to
 * the parser, and there it gets coerced via doNegate().
 *
 * {numericfail} is used because we would like "1..10" to lex as 1, dot_dot, 10.
 *
 * {realfail} is added to prevent the need for scanner
 * backup when the {real} rule fails to match completely.
 */
decdigit        [0-9]
hexdigit        [0-9A-Fa-f]
octdigit        [0-7]
bindigit        [0-1]
 
decinteger      {decdigit}(_?{decdigit})*
hexinteger      0[xX](_?{hexdigit})+
octinteger      0[oO](_?{octdigit})+
bininteger      0[bB](_?{bindigit})+
 
hexfail         0[xX]_?
octfail         0[oO]_?
binfail         0[bB]_?
 
numeric         (({decinteger}\.{decinteger}?)|(\.{decinteger}))
numericfail     {decinteger}\.\.
 
real            ({decinteger}|{numeric})[Ee][-+]?{decinteger}
realfail        ({decinteger}|{numeric})[Ee][-+]
 
/* Positional parameters don't accept underscores. */
param           \${decdigit}+
 
/*
 * An identifier immediately following an integer literal is disallowed because
 * in some cases it's ambiguous what is meant: for example, 0x1234 could be
 * either a hexinteger or a decinteger "0" and an identifier "x1234".  We can
 * detect such problems by seeing if integer_junk matches a longer substring
 * than any of the XXXinteger patterns (decinteger, hexinteger, octinteger,
 * bininteger).  One "junk" pattern is sufficient because
 * {decinteger}{identifier} will match all the same strings we'd match with
 * {hexinteger}{identifier} etc.
 *
 * Note that the rule for integer_junk must appear after the ones for
 * XXXinteger to make this work correctly: 0x1234 will match both hexinteger
 * and integer_junk, and we need hexinteger to be chosen in that case.
 *
 * Also disallow strings matched by numeric_junk, real_junk and param_junk
 * for consistency.
 */
integer_junk    {decinteger}{identifier}
numeric_junk    {numeric}{identifier}
real_junk       {real}{identifier}
param_junk      \${decdigit}+{identifier}
 
/* special characters for other dbms */
/* we have to react differently in compat mode */
informix_special    [\$]
 
other           .
 
/*
 * Dollar quoted strings are totally opaque, and no escaping is done on them.
 * Other quoted strings must allow some special characters such as single-quote
 *  and newline.
 * Embedded single-quotes are implemented both in the SQL standard
 *  style of two adjacent single quotes "''" and in the Postgres/Java style
 *  of escaped-quote "\'".
 * Other embedded escaped characters are matched explicitly and the leading
 *  backslash is dropped from the string.
 * Note that xcstart must appear before operator, as explained above!
 *  Also whitespace (comment) must appear before operator.
 */
 
/* some stuff needed for ecpg */
exec            [eE][xX][eE][cC]
sql             [sS][qQ][lL]
define          [dD][eE][fF][iI][nN][eE]
include         [iI][nN][cC][lL][uU][dD][eE]
include_next    [iI][nN][cC][lL][uU][dD][eE]_[nN][eE][xX][tT]
import          [iI][mM][pP][oO][rR][tT]
undef           [uU][nN][dD][eE][fF]
 
ccomment        "//".*\n
 
if              [iI][fF]
ifdef           [iI][fF][dD][eE][fF]
ifndef          [iI][fF][nN][dD][eE][fF]
else            [eE][lL][sS][eE]
elif            [eE][lL][iI][fF]
endif           [eE][nN][dD][iI][fF]
 
struct          [sS][tT][rR][uU][cC][tT]
 
exec_sql        {exec}{space}*{sql}{space}*
ipdigit         ({decdigit}|{decdigit}{decdigit}|{decdigit}{decdigit}{decdigit})
ip              {ipdigit}\.{ipdigit}\.{ipdigit}\.{ipdigit}
 
/* we might want to parse all cpp include files */
cppinclude      {space}*#{include}{space}*
cppinclude_next     {space}*#{include_next}{space}*
 
/* take care of cpp lines, they may also be continued */
/* first a general line for all commands not starting with "i" */
/* and then the other commands starting with "i", we have to add these
 * separately because the cppline production would match on "include" too
 */
cppline         {space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+\/)|.|\\{space}*{newline})*{newline}
 
%%
 
%{
        /* 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;
                }
 
{right_arrow}   {
                    return RIGHT_ARROW;
                }
 
{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;
                            if (yytext[0] == '-' && yytext[1] == '>')
                                return RIGHT_ARROW;
                        }
                    }
 
                    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);
                }
 
%%
 
/* LCOV_EXCL_STOP */
 
void
lex_init(void)
{
    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);
}
 
static void
addlit(char *ytext, int yleng)
{
    /* 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';
}
 
static void
addlitchar(unsigned char ychar)
{
    /* 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';
}
 
/*
 * Process {decinteger}, {hexinteger}, etc.  Note this will also do the right
 * thing with {numeric}, ie digits and a decimal point.
 */
static int
process_integer_literal(const char *token, YYSTYPE *lval, int base)
{
    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;
}
 
static void
parse_include(void)
{
    /* 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);
}
 
/*
 * ecpg_isspace() --- return true if flex scanner considers char whitespace
 */
static bool
ecpg_isspace(char ch)
{
    if (ch == ' ' ||
        ch == '\t' ||
        ch == '\n' ||
        ch == '\r' ||
        ch == '\f' ||
        ch == '\v')
        return true;
    return false;
}
 
/*
 * If yytext matches a define symbol, begin scanning the symbol's value
 * and return true
 */
static bool
isdefine(void)
{
    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;
}
 
/*
 * Handle replacement of INFORMIX built-in defines.  This works just
 * like isdefine() except for the source of the string to scan.
 */
static bool
isinformixdefine(void)
{
    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;
}