LCOV - code coverage report
Current view: top level - src/interfaces/ecpg/preproc - pgc.l (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 101 130 77.7 %
Date: 2024-04-25 01:13:18 Functions: 7 8 87.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : %top{
       2             : /*-------------------------------------------------------------------------
       3             :  *
       4             :  * pgc.l
       5             :  *    lexical scanner for ecpg
       6             :  *
       7             :  * This is a modified version of src/backend/parser/scan.l
       8             :  *
       9             :  * The ecpg scanner is not backup-free, so the fail rules are
      10             :  * only here to simplify syncing this file with scan.l.
      11             :  *
      12             :  *
      13             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
      14             :  * Portions Copyright (c) 1994, Regents of the University of California
      15             :  *
      16             :  * IDENTIFICATION
      17             :  *    src/interfaces/ecpg/preproc/pgc.l
      18             :  *
      19             :  *-------------------------------------------------------------------------
      20             :  */
      21             : #include "postgres_fe.h"
      22             : 
      23             : #include <ctype.h>
      24             : #include <limits.h>
      25             : 
      26             : #include "common/string.h"
      27             : 
      28             : #include "preproc_extern.h"
      29             : #include "preproc.h"
      30             : }
      31             : 
      32             : %{
      33             : 
      34             : /* LCOV_EXCL_START */
      35             : 
      36             : extern YYSTYPE base_yylval;
      37             : 
      38             : static int      xcdepth = 0;    /* depth of nesting in slash-star comments */
      39             : static char    *dolqstart = NULL;   /* current $foo$ quote start string */
      40             : 
      41             : /*
      42             :  * literalbuf is used to accumulate literal values when multiple rules
      43             :  * are needed to parse a single literal.  Call startlit to reset buffer
      44             :  * to empty, addlit to add text.  Note that the buffer is permanently
      45             :  * malloc'd to the largest size needed so far in the current run.
      46             :  */
      47             : static char    *literalbuf = NULL;      /* expandable buffer */
      48             : static int      literallen;             /* actual current length */
      49             : static int      literalalloc;           /* current allocated buffer size */
      50             : 
      51             : /* Used for detecting global state together with braces_open */
      52             : static int      parenths_open;
      53             : 
      54             : /* Used to tell parse_include() whether the command was #include or #include_next */
      55             : static bool     include_next;
      56             : 
      57             : #define startlit()  (literalbuf[0] = '\0', literallen = 0)
      58             : static void addlit(char *ytext, int yleng);
      59             : static void addlitchar(unsigned char ychar);
      60             : static int  process_integer_literal(const char *token, YYSTYPE *lval, int base);
      61             : static void parse_include(void);
      62             : static bool ecpg_isspace(char ch);
      63             : static bool isdefine(void);
      64             : static bool isinformixdefine(void);
      65             : 
      66             : char *token_start;
      67             : 
      68             : /* vars to keep track of start conditions when scanning literals */
      69             : static int state_before_str_start;
      70             : static int state_before_str_stop;
      71             : 
      72             : /*
      73             :  * State for handling include files and macro expansion.  We use a new
      74             :  * flex input buffer for each level of include or macro, and create a
      75             :  * struct _yy_buffer to remember the previous level.  There is not a struct
      76             :  * for the currently active input source; that state is kept in the global
      77             :  * variables YY_CURRENT_BUFFER, yylineno, and input_filename.
      78             :  */
      79             : static struct _yy_buffer
      80             : {
      81             :     YY_BUFFER_STATE     buffer;
      82             :     long                lineno;
      83             :     char               *filename;
      84             :     struct _yy_buffer  *next;
      85             : } *yy_buffer = NULL;
      86             : 
      87             : /*
      88             :  * Vars for handling ifdef/elif/endif constructs.  preproc_tos is the current
      89             :  * nesting depth of such constructs, and stacked_if_value[preproc_tos] is the
      90             :  * state for the innermost level.  (For convenience, stacked_if_value[0] is
      91             :  * initialized as though we are in the active branch of some outermost IF.)
      92             :  * The active field is true if the current branch is active (being expanded).
      93             :  * The saw_active field is true if we have found any successful branch,
      94             :  * so that all subsequent branches of this level should be skipped.
      95             :  * The else_branch field is true if we've found an 'else' (so that another
      96             :  * 'else' or 'elif' at this level is an error.)
      97             :  * For IFs nested within an inactive branch, all branches always have active
      98             :  * set to false, but saw_active and else_branch are maintained normally.
      99             :  * ifcond is valid only while evaluating an if-condition; it's true if we
     100             :  * are doing ifdef, false if ifndef.
     101             :  */
     102             : #define MAX_NESTED_IF 128
     103             : static short preproc_tos;
     104             : static bool ifcond;
     105             : static struct _if_value
     106             : {
     107             :     bool        active;
     108             :     bool        saw_active;
     109             :     bool        else_branch;
     110             : } stacked_if_value[MAX_NESTED_IF];
     111             : 
     112             : %}
     113             : 
     114             : %option 8bit
     115             : %option never-interactive
     116             : %option nodefault
     117             : %option noinput
     118             : %option noyywrap
     119             : %option warn
     120             : %option yylineno
     121             : %option prefix="base_yy"
     122             : 
     123             : /*
     124             :  * OK, here is a short description of lex/flex rules behavior.
     125             :  * The longest pattern which matches an input string is always chosen.
     126             :  * For equal-length patterns, the first occurring in the rules list is chosen.
     127             :  * INITIAL is the starting state, to which all non-conditional rules apply.
     128             :  * Exclusive states change parsing rules while the state is active.  When in
     129             :  * an exclusive state, only those rules defined for that state apply.
     130             :  *
     131             :  * We use exclusive states for quoted strings, extended comments,
     132             :  * and to eliminate parsing troubles for numeric strings.
     133             :  * Exclusive states:
     134             :  *  <xb> bit string literal
     135             :  *  <xc> extended C-style comments
     136             :  *  <xd> delimited identifiers (double-quoted identifiers)
     137             :  *  <xdc> double-quoted strings in C
     138             :  *  <xh> hexadecimal byte string
     139             :  *  <xn> national character quoted strings
     140             :  *  <xq> standard quoted strings
     141             :  *  <xqs> quote stop (detect continued strings)
     142             :  *  <xe> extended quoted strings (support backslash escape sequences)
     143             :  *  <xqc> single-quoted strings in C
     144             :  *  <xdolq> $foo$ quoted strings
     145             :  *  <xui> quoted identifier with Unicode escapes
     146             :  *  <xus> quoted string with Unicode escapes
     147             :  *  <xcond> condition of an EXEC SQL IFDEF construct
     148             :  *  <xskip> skipping the inactive part of an EXEC SQL IFDEF construct
     149             :  *
     150             :  * Note: we intentionally don't mimic the backend's <xeu> state; we have
     151             :  * no need to distinguish it from <xe> state.
     152             :  *
     153             :  * Remember to add an <<EOF>> case whenever you add a new exclusive state!
     154             :  * The default one is probably not the right thing.
     155             :  */
     156             : 
     157             : %x xb
     158             : %x xc
     159             : %x xd
     160             : %x xdc
     161             : %x xh
     162             : %x xn
     163             : %x xq
     164             : %x xqs
     165             : %x xe
     166             : %x xqc
     167             : %x xdolq
     168             : %x xui
     169             : %x xus
     170             : %x xcond
     171             : %x xskip
     172             : 
     173             : /* Additional exclusive states that are specific to ECPG */
     174             : %x C SQL incl def def_ident undef
     175             : 
     176             : /*
     177             :  * In order to make the world safe for Windows and Mac clients as well as
     178             :  * Unix ones, we accept either \n or \r as a newline.  A DOS-style \r\n
     179             :  * sequence will be seen as two successive newlines, but that doesn't cause
     180             :  * any problems.  SQL-style comments, which start with -- and extend to the
     181             :  * next newline, are treated as equivalent to a single whitespace character.
     182             :  *
     183             :  * NOTE a fine point: if there is no newline following --, we will absorb
     184             :  * everything to the end of the input as a comment.  This is correct.  Older
     185             :  * versions of Postgres failed to recognize -- as a comment if the input
     186             :  * did not end with a newline.
     187             :  *
     188             :  * non_newline_space tracks all space characters except newlines.
     189             :  *
     190             :  * XXX if you change the set of whitespace characters, fix ecpg_isspace()
     191             :  * to agree.
     192             :  */
     193             : 
     194             : space               [ \t\n\r\f\v]
     195             : non_newline_space   [ \t\f\v]
     196             : newline             [\n\r]
     197             : non_newline         [^\n\r]
     198             : 
     199             : comment         ("--"{non_newline}*)
     200             : 
     201             : whitespace      ({space}+|{comment})
     202             : 
     203             : /*
     204             :  * SQL requires at least one newline in the whitespace separating
     205             :  * string literals that are to be concatenated.  Silly, but who are we
     206             :  * to argue?  Note that {whitespace_with_newline} should not have * after
     207             :  * it, whereas {whitespace} should generally have a * after it...
     208             :  */
     209             : 
     210             : non_newline_whitespace  ({non_newline_space}|{comment})
     211             : whitespace_with_newline ({non_newline_whitespace}*{newline}{whitespace}*)
     212             : 
     213             : quote           '
     214             : /* If we see {quote} then {quotecontinue}, the quoted string continues */
     215             : quotecontinue   {whitespace_with_newline}{quote}
     216             : 
     217             : /*
     218             :  * {quotecontinuefail} is needed to avoid lexer backup when we fail to match
     219             :  * {quotecontinue}.  It might seem that this could just be {whitespace}*,
     220             :  * but if there's a dash after {whitespace_with_newline}, it must be consumed
     221             :  * to see if there's another dash --- which would start a {comment} and thus
     222             :  * allow continuation of the {quotecontinue} token.
     223             :  */
     224             : quotecontinuefail   {whitespace}*"-"?
     225             : 
     226             : /* Bit string
     227             :  */
     228             : xbstart         [bB]{quote}
     229             : xbinside        [^']*
     230             : 
     231             : /* Hexadecimal byte string */
     232             : xhstart         [xX]{quote}
     233             : xhinside        [^']*
     234             : 
     235             : /* National character */
     236             : xnstart         [nN]{quote}
     237             : 
     238             : /* Quoted string that allows backslash escapes */
     239             : xestart         [eE]{quote}
     240             : xeinside        [^\\']+
     241             : xeescape        [\\][^0-7]
     242             : xeoctesc        [\\][0-7]{1,3}
     243             : xehexesc        [\\]x[0-9A-Fa-f]{1,2}
     244             : xeunicode       [\\](u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})
     245             : 
     246             : /* Extended quote
     247             :  * xqdouble implements embedded quote, ''''
     248             :  */
     249             : xqstart         {quote}
     250             : xqdouble        {quote}{quote}
     251             : xqcquote        [\\]{quote}
     252             : xqinside        [^']+
     253             : 
     254             : /* $foo$ style quotes ("dollar quoting")
     255             :  * The quoted string starts with $foo$ where "foo" is an optional string
     256             :  * in the form of an identifier, except that it may not contain "$",
     257             :  * and extends to the first occurrence of an identical string.
     258             :  * There is *no* processing of the quoted text.
     259             :  *
     260             :  * {dolqfailed} is an error rule to avoid scanner backup when {dolqdelim}
     261             :  * fails to match its trailing "$".
     262             :  */
     263             : dolq_start      [A-Za-z\200-\377_]
     264             : dolq_cont       [A-Za-z\200-\377_0-9]
     265             : dolqdelim       \$({dolq_start}{dolq_cont}*)?\$
     266             : dolqfailed      \${dolq_start}{dolq_cont}*
     267             : dolqinside      [^$]+
     268             : 
     269             : /* Double quote
     270             :  * Allows embedded spaces and other special characters into identifiers.
     271             :  */
     272             : dquote          \"
     273             : xdstart         {dquote}
     274             : xdstop          {dquote}
     275             : xddouble        {dquote}{dquote}
     276             : xdinside        [^"]+
     277             : 
     278             : /* Quoted identifier with Unicode escapes */
     279             : xuistart        [uU]&{dquote}
     280             : 
     281             : /* Quoted string with Unicode escapes */
     282             : xusstart        [uU]&{quote}
     283             : 
     284             : /* special stuff for C strings */
     285             : xdcqq           \\\\
     286             : xdcqdq          \\\"
     287             : xdcother        [^"]
     288             : xdcinside       ({xdcqq}|{xdcqdq}|{xdcother})
     289             : 
     290             : 
     291             : /* C-style comments
     292             :  *
     293             :  * The "extended comment" syntax closely resembles allowable operator syntax.
     294             :  * The tricky part here is to get lex to recognize a string starting with
     295             :  * slash-star as a comment, when interpreting it as an operator would produce
     296             :  * a longer match --- remember lex will prefer a longer match!  Also, if we
     297             :  * have something like plus-slash-star, lex will think this is a 3-character
     298             :  * operator whereas we want to see it as a + operator and a comment start.
     299             :  * The solution is two-fold:
     300             :  * 1. append {op_chars}* to xcstart so that it matches as much text as
     301             :  *    {operator} would. Then the tie-breaker (first matching rule of same
     302             :  *    length) ensures xcstart wins.  We put back the extra stuff with yyless()
     303             :  *    in case it contains a star-slash that should terminate the comment.
     304             :  * 2. In the operator rule, check for slash-star within the operator, and
     305             :  *    if found throw it back with yyless().  This handles the plus-slash-star
     306             :  *    problem.
     307             :  * Dash-dash comments have similar interactions with the operator rule.
     308             :  */
     309             : xcstart         \/\*{op_chars}*
     310             : xcstop          \*+\/
     311             : xcinside        [^*/]+
     312             : 
     313             : ident_start     [A-Za-z\200-\377_]
     314             : ident_cont      [A-Za-z\200-\377_0-9\$]
     315             : 
     316             : identifier      {ident_start}{ident_cont}*
     317             : 
     318             : array           ({ident_cont}|{whitespace}|[\[\]\+\-\*\%\/\(\)\>\.])*
     319             : 
     320             : /* Assorted special-case operators and operator-like tokens */
     321             : typecast        "::"
     322             : dot_dot         \.\.
     323             : colon_equals    ":="
     324             : 
     325             : /*
     326             :  * These operator-like tokens (unlike the above ones) also match the {operator}
     327             :  * rule, which means that they might be overridden by a longer match if they
     328             :  * are followed by a comment start or a + or - character. Accordingly, if you
     329             :  * add to this list, you must also add corresponding code to the {operator}
     330             :  * block to return the correct token in such cases. (This is not needed in
     331             :  * psqlscan.l since the token value is ignored there.)
     332             :  */
     333             : equals_greater  "=>"
     334             : less_equals     "<="
     335             : greater_equals  ">="
     336             : less_greater    "<>"
     337             : not_equals      "!="
     338             : 
     339             : /*
     340             :  * "self" is the set of chars that should be returned as single-character
     341             :  * tokens.  "op_chars" is the set of chars that can make up "Op" tokens,
     342             :  * which can be one or more characters long (but if a single-char token
     343             :  * appears in the "self" set, it is not to be returned as an Op).  Note
     344             :  * that the sets overlap, but each has some chars that are not in the other.
     345             :  *
     346             :  * If you change either set, adjust the character lists appearing in the
     347             :  * rule for "operator"!
     348             :  */
     349             : self            [,()\[\].;\:\+\-\*\/\%\^\<\>\=]
     350             : op_chars        [\~\!\@\#\^\&\|\`\?\+\-\*\/\%\<\>\=]
     351             : operator        {op_chars}+
     352             : 
     353             : /*
     354             :  * Numbers
     355             :  *
     356             :  * Unary minus is not part of a number here.  Instead we pass it separately to
     357             :  * the parser, and there it gets coerced via doNegate().
     358             :  *
     359             :  * {numericfail} is used because we would like "1..10" to lex as 1, dot_dot, 10.
     360             :  *
     361             :  * {realfail} is added to prevent the need for scanner
     362             :  * backup when the {real} rule fails to match completely.
     363             :  */
     364             : decdigit        [0-9]
     365             : hexdigit        [0-9A-Fa-f]
     366             : octdigit        [0-7]
     367             : bindigit        [0-1]
     368             : 
     369             : decinteger      {decdigit}(_?{decdigit})*
     370             : hexinteger      0[xX](_?{hexdigit})+
     371             : octinteger      0[oO](_?{octdigit})+
     372             : bininteger      0[bB](_?{bindigit})+
     373             : 
     374             : hexfail         0[xX]_?
     375             : octfail         0[oO]_?
     376             : binfail         0[bB]_?
     377             : 
     378             : numeric         (({decinteger}\.{decinteger}?)|(\.{decinteger}))
     379             : numericfail     {decdigit}+\.\.
     380             : 
     381             : real            ({decinteger}|{numeric})[Ee][-+]?{decinteger}
     382             : realfail        ({decinteger}|{numeric})[Ee][-+]
     383             : 
     384             : decinteger_junk {decinteger}{ident_start}
     385             : hexinteger_junk {hexinteger}{ident_start}
     386             : octinteger_junk {octinteger}{ident_start}
     387             : bininteger_junk {bininteger}{ident_start}
     388             : numeric_junk    {numeric}{ident_start}
     389             : real_junk       {real}{ident_start}
     390             : 
     391             : param           \${decinteger}
     392             : param_junk      \${decinteger}{ident_start}
     393             : 
     394             : /* special characters for other dbms */
     395             : /* we have to react differently in compat mode */
     396             : informix_special    [\$]
     397             : 
     398             : other           .
     399             : 
     400             : /*
     401             :  * Dollar quoted strings are totally opaque, and no escaping is done on them.
     402             :  * Other quoted strings must allow some special characters such as single-quote
     403             :  *  and newline.
     404             :  * Embedded single-quotes are implemented both in the SQL standard
     405             :  *  style of two adjacent single quotes "''" and in the Postgres/Java style
     406             :  *  of escaped-quote "\'".
     407             :  * Other embedded escaped characters are matched explicitly and the leading
     408             :  *  backslash is dropped from the string.
     409             :  * Note that xcstart must appear before operator, as explained above!
     410             :  *  Also whitespace (comment) must appear before operator.
     411             :  */
     412             : 
     413             : /* some stuff needed for ecpg */
     414             : exec            [eE][xX][eE][cC]
     415             : sql             [sS][qQ][lL]
     416             : define          [dD][eE][fF][iI][nN][eE]
     417             : include         [iI][nN][cC][lL][uU][dD][eE]
     418             : include_next    [iI][nN][cC][lL][uU][dD][eE]_[nN][eE][xX][tT]
     419             : import          [iI][mM][pP][oO][rR][tT]
     420             : undef           [uU][nN][dD][eE][fF]
     421             : 
     422             : ccomment        "//".*\n
     423             : 
     424             : if              [iI][fF]
     425             : ifdef           [iI][fF][dD][eE][fF]
     426             : ifndef          [iI][fF][nN][dD][eE][fF]
     427             : else            [eE][lL][sS][eE]
     428             : elif            [eE][lL][iI][fF]
     429             : endif           [eE][nN][dD][iI][fF]
     430             : 
     431             : struct          [sS][tT][rR][uU][cC][tT]
     432             : 
     433             : exec_sql        {exec}{space}*{sql}{space}*
     434             : ipdigit         ({decdigit}|{decdigit}{decdigit}|{decdigit}{decdigit}{decdigit})
     435             : ip              {ipdigit}\.{ipdigit}\.{ipdigit}\.{ipdigit}
     436             : 
     437             : /* we might want to parse all cpp include files */
     438             : cppinclude      {space}*#{include}{space}*
     439             : cppinclude_next     {space}*#{include_next}{space}*
     440             : 
     441             : /* take care of cpp lines, they may also be continued */
     442             : /* first a general line for all commands not starting with "i" */
     443             : /* and then the other commands starting with "i", we have to add these
     444             :  * separately because the cppline production would match on "include" too
     445             :  */
     446             : cppline         {space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+\/)|.|\\{space}*{newline})*{newline}
     447             : 
     448             : %%
     449             : 
     450             : %{
     451             :         /* code to execute during start of each call of yylex() */
     452             :         char *newdefsymbol = NULL;
     453             : 
     454             :         token_start = NULL;
     455             : %}
     456             : 
     457             : <SQL>{
     458             : {whitespace}    {
     459             :                     /* ignore */
     460             :                 }
     461             : } /* <SQL> */
     462             : 
     463             : <C,SQL>{
     464             : {xcstart}       {
     465             :                     token_start = yytext;
     466             :                     state_before_str_start = YYSTATE;
     467             :                     xcdepth = 0;
     468             :                     BEGIN(xc);
     469             :                     /* Put back any characters past slash-star; see above */
     470             :                     yyless(2);
     471             :                     fputs("/*", yyout);
     472             :                 }
     473             : } /* <C,SQL> */
     474             : 
     475             : <xc>{
     476             : {xcstart}       {
     477             :                     if (state_before_str_start == SQL)
     478             :                     {
     479             :                         xcdepth++;
     480             :                         /* Put back any characters past slash-star; see above */
     481             :                         yyless(2);
     482             :                         fputs("/_*", yyout);
     483             :                     }
     484             :                     else if (state_before_str_start == C)
     485             :                     {
     486             :                         ECHO;
     487             :                     }
     488             :                 }
     489             : 
     490             : {xcstop}        {
     491             :                     if (state_before_str_start == SQL)
     492             :                     {
     493             :                         if (xcdepth <= 0)
     494             :                         {
     495             :                             ECHO;
     496             :                             BEGIN(SQL);
     497             :                             token_start = NULL;
     498             :                         }
     499             :                         else
     500             :                         {
     501             :                             xcdepth--;
     502             :                             fputs("*_/", yyout);
     503             :                         }
     504             :                     }
     505             :                     else if (state_before_str_start == C)
     506             :                     {
     507             :                         ECHO;
     508             :                         BEGIN(C);
     509             :                         token_start = NULL;
     510             :                     }
     511             :                 }
     512             : 
     513             : {xcinside}      {
     514             :                     ECHO;
     515             :                 }
     516             : 
     517             : {op_chars}      {
     518             :                     ECHO;
     519             :                 }
     520             : 
     521             : \*+             {
     522             :                     ECHO;
     523             :                 }
     524             : 
     525             : <<EOF>>         {
     526             :                     mmfatal(PARSE_ERROR, "unterminated /* comment");
     527             :                 }
     528             : } /* <xc> */
     529             : 
     530             : <SQL>{
     531             : {xbstart}       {
     532             :                     token_start = yytext;
     533             :                     state_before_str_start = YYSTATE;
     534             :                     BEGIN(xb);
     535             :                     startlit();
     536             :                 }
     537             : } /* <SQL> */
     538             : 
     539             : <xh>{xhinside}    |
     540             : <xb>{xbinside}    {
     541             :                     addlit(yytext, yyleng);
     542             :                 }
     543             : <xb><<EOF>>       { mmfatal(PARSE_ERROR, "unterminated bit string literal"); }
     544             : 
     545             : <SQL>{xhstart}    {
     546             :                     token_start = yytext;
     547             :                     state_before_str_start = YYSTATE;
     548             :                     BEGIN(xh);
     549             :                     startlit();
     550             :                 }
     551             : <xh><<EOF>>       { mmfatal(PARSE_ERROR, "unterminated hexadecimal string literal"); }
     552             : 
     553             : <C>{xqstart}  {
     554             :                     token_start = yytext;
     555             :                     state_before_str_start = YYSTATE;
     556             :                     BEGIN(xqc);
     557             :                     startlit();
     558             :                 }
     559             : 
     560             : <SQL>{
     561             : {xnstart}       {
     562             :                     /* National character.
     563             :                      * Transfer it as-is to the backend.
     564             :                      */
     565             :                     token_start = yytext;
     566             :                     state_before_str_start = YYSTATE;
     567             :                     BEGIN(xn);
     568             :                     startlit();
     569             :                 }
     570             : 
     571             : {xqstart}       {
     572             :                     token_start = yytext;
     573             :                     state_before_str_start = YYSTATE;
     574             :                     BEGIN(xq);
     575             :                     startlit();
     576             :                 }
     577             : {xestart}       {
     578             :                     token_start = yytext;
     579             :                     state_before_str_start = YYSTATE;
     580             :                     BEGIN(xe);
     581             :                     startlit();
     582             :                 }
     583             : {xusstart}      {
     584             :                     token_start = yytext;
     585             :                     state_before_str_start = YYSTATE;
     586             :                     BEGIN(xus);
     587             :                     startlit();
     588             :                 }
     589             : } /* <SQL> */
     590             : 
     591             : <xb,xh,xq,xqc,xe,xn,xus>{quote} {
     592             :                     /*
     593             :                      * When we are scanning a quoted string and see an end
     594             :                      * quote, we must look ahead for a possible continuation.
     595             :                      * If we don't see one, we know the end quote was in fact
     596             :                      * the end of the string.  To reduce the lexer table size,
     597             :                      * we use a single "xqs" state to do the lookahead for all
     598             :                      * types of strings.
     599             :                      */
     600             :                     state_before_str_stop = YYSTATE;
     601             :                     BEGIN(xqs);
     602             :                 }
     603             : <xqs>{quotecontinue} {
     604             :                     /*
     605             :                      * Found a quote continuation, so return to the in-quote
     606             :                      * state and continue scanning the literal.  Nothing is
     607             :                      * added to the literal's contents.
     608             :                      */
     609             :                     BEGIN(state_before_str_stop);
     610             :                 }
     611             : <xqs>{quotecontinuefail} |
     612             : <xqs>{other} |
     613             : <xqs><<EOF>>  {
     614             :                     /*
     615             :                      * Failed to see a quote continuation.  Throw back
     616             :                      * everything after the end quote, and handle the string
     617             :                      * according to the state we were in previously.
     618             :                      */
     619             :                     yyless(0);
     620             :                     BEGIN(state_before_str_start);
     621             : 
     622             :                     switch (state_before_str_stop)
     623             :                     {
     624             :                         case xb:
     625             :                             if (literalbuf[strspn(literalbuf, "01")] != '\0')
     626             :                                 mmerror(PARSE_ERROR, ET_ERROR, "invalid bit string literal");
     627             :                             base_yylval.str = psprintf("b'%s'", literalbuf);
     628             :                             return BCONST;
     629             :                         case xh:
     630             :                             if (literalbuf[strspn(literalbuf, "0123456789abcdefABCDEF")] != '\0')
     631             :                                 mmerror(PARSE_ERROR, ET_ERROR, "invalid hexadecimal string literal");
     632             :                             base_yylval.str = psprintf("x'%s'", literalbuf);
     633             :                             return XCONST;
     634             :                         case xq:
     635             :                             /* fallthrough */
     636             :                         case xqc:
     637             :                             base_yylval.str = psprintf("'%s'", literalbuf);
     638             :                             return SCONST;
     639             :                         case xe:
     640             :                             base_yylval.str = psprintf("E'%s'", literalbuf);
     641             :                             return SCONST;
     642             :                         case xn:
     643             :                             base_yylval.str = psprintf("N'%s'", literalbuf);
     644             :                             return SCONST;
     645             :                         case xus:
     646             :                             base_yylval.str = psprintf("U&'%s'", literalbuf);
     647             :                             return USCONST;
     648             :                         default:
     649             :                             mmfatal(PARSE_ERROR, "unhandled previous state in xqs\n");
     650             :                     }
     651             :                 }
     652             : 
     653             : <xq,xe,xn,xus>{xqdouble}  { addlit(yytext, yyleng); }
     654             : <xqc>{xqcquote}               { addlit(yytext, yyleng); }
     655             : <xq,xqc,xn,xus>{xqinside} { addlit(yytext, yyleng); }
     656             : <xe>{xeinside}  {
     657             :                     addlit(yytext, yyleng);
     658             :                 }
     659             : <xe>{xeunicode} {
     660             :                     addlit(yytext, yyleng);
     661             :                 }
     662             : <xe>{xeescape}  {
     663             :                     addlit(yytext, yyleng);
     664             :                 }
     665             : <xe>{xeoctesc}  {
     666             :                     addlit(yytext, yyleng);
     667             :                 }
     668             : <xe>{xehexesc}  {
     669             :                     addlit(yytext, yyleng);
     670             :                 }
     671             : <xe>.         {
     672             :                     /* This is only needed for \ just before EOF */
     673             :                     addlitchar(yytext[0]);
     674             :                 }
     675             : <xq,xqc,xe,xn,xus><<EOF>> { mmfatal(PARSE_ERROR, "unterminated quoted string"); }
     676             : 
     677             : <SQL>{
     678             : {dolqdelim}     {
     679             :                     token_start = yytext;
     680             :                     if (dolqstart)
     681             :                         free(dolqstart);
     682             :                     dolqstart = mm_strdup(yytext);
     683             :                     BEGIN(xdolq);
     684             :                     startlit();
     685             :                     addlit(yytext, yyleng);
     686             :                 }
     687             : {dolqfailed}    {
     688             :                     /* throw back all but the initial "$" */
     689             :                     yyless(1);
     690             :                     /* and treat it as {other} */
     691             :                     return yytext[0];
     692             :                 }
     693             : } /* <SQL> */
     694             : 
     695             : <xdolq>{dolqdelim} {
     696             :                     if (strcmp(yytext, dolqstart) == 0)
     697             :                     {
     698             :                         addlit(yytext, yyleng);
     699             :                         free(dolqstart);
     700             :                         dolqstart = NULL;
     701             :                         BEGIN(SQL);
     702             :                         base_yylval.str = mm_strdup(literalbuf);
     703             :                         return SCONST;
     704             :                     }
     705             :                     else
     706             :                     {
     707             :                         /*
     708             :                          * When we fail to match $...$ to dolqstart, transfer
     709             :                          * the $... part to the output, but put back the final
     710             :                          * $ for rescanning.  Consider $delim$...$junk$delim$
     711             :                          */
     712             :                         addlit(yytext, yyleng - 1);
     713             :                         yyless(yyleng - 1);
     714             :                     }
     715             :                 }
     716             : <xdolq>{dolqinside} {
     717             :                     addlit(yytext, yyleng);
     718             :                 }
     719             : <xdolq>{dolqfailed} {
     720             :                     addlit(yytext, yyleng);
     721             :                 }
     722             : <xdolq>.      {
     723             :                     /* single quote or dollar sign */
     724             :                     addlitchar(yytext[0]);
     725             :                 }
     726             : <xdolq><<EOF>>    { mmfatal(PARSE_ERROR, "unterminated dollar-quoted string"); }
     727             : 
     728             : <SQL>{
     729             : {xdstart}       {
     730             :                     state_before_str_start = YYSTATE;
     731             :                     BEGIN(xd);
     732             :                     startlit();
     733             :                 }
     734             : {xuistart}      {
     735             :                     state_before_str_start = YYSTATE;
     736             :                     BEGIN(xui);
     737             :                     startlit();
     738             :                 }
     739             : } /* <SQL> */
     740             : 
     741             : <xd>{xdstop}  {
     742             :                     BEGIN(state_before_str_start);
     743             :                     if (literallen == 0)
     744             :                         mmerror(PARSE_ERROR, ET_ERROR, "zero-length delimited identifier");
     745             :                     /*
     746             :                      * The server will truncate the identifier here.  We do
     747             :                      * not, as (1) it does not change the result; (2) we don't
     748             :                      * know what NAMEDATALEN the server might use; (3) this
     749             :                      * code path is also taken for literal query strings in
     750             :                      * PREPARE and EXECUTE IMMEDIATE, which can certainly be
     751             :                      * longer than NAMEDATALEN.
     752             :                      */
     753             :                     base_yylval.str = mm_strdup(literalbuf);
     754             :                     return CSTRING;
     755             :                 }
     756             : <xdc>{xdstop} {
     757             :                     BEGIN(state_before_str_start);
     758             :                     base_yylval.str = mm_strdup(literalbuf);
     759             :                     return CSTRING;
     760             :                 }
     761             : <xui>{dquote} {
     762             :                     BEGIN(state_before_str_start);
     763             :                     if (literallen == 0)
     764             :                         mmerror(PARSE_ERROR, ET_ERROR, "zero-length delimited identifier");
     765             :                     /* The backend will truncate the identifier here. We do not as it does not change the result. */
     766             :                     base_yylval.str = psprintf("U&\"%s\"", literalbuf);
     767             :                     return UIDENT;
     768             :                 }
     769             : <xd,xui>{xddouble}    {
     770             :                     addlit(yytext, yyleng);
     771             :                 }
     772             : <xd,xui>{xdinside}    {
     773             :                     addlit(yytext, yyleng);
     774             :                 }
     775             : <xd,xui><<EOF>>   { mmfatal(PARSE_ERROR, "unterminated quoted identifier"); }
     776             : <C>{xdstart}  {
     777             :                     state_before_str_start = YYSTATE;
     778             :                     BEGIN(xdc);
     779             :                     startlit();
     780             :                 }
     781             : <xdc>{xdcinside}  {
     782             :                     addlit(yytext, yyleng);
     783             :                 }
     784             : <xdc><<EOF>>  { mmfatal(PARSE_ERROR, "unterminated quoted string"); }
     785             : 
     786             : <SQL>{
     787             : {typecast}      {
     788             :                     return TYPECAST;
     789             :                 }
     790             : 
     791             : {dot_dot}       {
     792             :                     return DOT_DOT;
     793             :                 }
     794             : 
     795             : {colon_equals}  {
     796             :                     return COLON_EQUALS;
     797             :                 }
     798             : 
     799             : {equals_greater} {
     800             :                     return EQUALS_GREATER;
     801             :                 }
     802             : 
     803             : {less_equals}   {
     804             :                     return LESS_EQUALS;
     805             :                 }
     806             : 
     807             : {greater_equals} {
     808             :                     return GREATER_EQUALS;
     809             :                 }
     810             : 
     811             : {less_greater}  {
     812             :                     /* We accept both "<>" and "!=" as meaning NOT_EQUALS */
     813             :                     return NOT_EQUALS;
     814             :                 }
     815             : 
     816             : {not_equals}    {
     817             :                     /* We accept both "<>" and "!=" as meaning NOT_EQUALS */
     818             :                     return NOT_EQUALS;
     819             :                 }
     820             : 
     821             : {informix_special}  {
     822             :               /* are we simulating Informix? */
     823             :                 if (INFORMIX_MODE)
     824             :                 {
     825             :                     unput(':');
     826             :                 }
     827             :                 else
     828             :                     return yytext[0];
     829             :                 }
     830             : 
     831             : {self}          {
     832             :                     /*
     833             :                      * We may find a ';' inside a structure
     834             :                      * definition in a TYPE or VAR statement.
     835             :                      * This is not an EOL marker.
     836             :                      */
     837             :                     if (yytext[0] == ';' && struct_level == 0)
     838             :                         BEGIN(C);
     839             :                     return yytext[0];
     840             :                 }
     841             : 
     842             : {operator}      {
     843             :                     /*
     844             :                      * Check for embedded slash-star or dash-dash; those
     845             :                      * are comment starts, so operator must stop there.
     846             :                      * Note that slash-star or dash-dash at the first
     847             :                      * character will match a prior rule, not this one.
     848             :                      */
     849             :                     int         nchars = yyleng;
     850             :                     char       *slashstar = strstr(yytext, "/*");
     851             :                     char       *dashdash = strstr(yytext, "--");
     852             : 
     853             :                     if (slashstar && dashdash)
     854             :                     {
     855             :                         /* if both appear, take the first one */
     856             :                         if (slashstar > dashdash)
     857             :                             slashstar = dashdash;
     858             :                     }
     859             :                     else if (!slashstar)
     860             :                         slashstar = dashdash;
     861             :                     if (slashstar)
     862             :                         nchars = slashstar - yytext;
     863             : 
     864             :                     /*
     865             :                      * For SQL compatibility, '+' and '-' cannot be the
     866             :                      * last char of a multi-char operator unless the operator
     867             :                      * contains chars that are not in SQL operators.
     868             :                      * The idea is to lex '=-' as two operators, but not
     869             :                      * to forbid operator names like '?-' that could not be
     870             :                      * sequences of SQL operators.
     871             :                      */
     872             :                     if (nchars > 1 &&
     873             :                         (yytext[nchars - 1] == '+' ||
     874             :                          yytext[nchars - 1] == '-'))
     875             :                     {
     876             :                         int         ic;
     877             : 
     878             :                         for (ic = nchars - 2; ic >= 0; ic--)
     879             :                         {
     880             :                             char c = yytext[ic];
     881             :                             if (c == '~' || c == '!' || c == '@' ||
     882             :                                 c == '#' || c == '^' || c == '&' ||
     883             :                                 c == '|' || c == '`' || c == '?' ||
     884             :                                 c == '%')
     885             :                                 break;
     886             :                         }
     887             :                         if (ic < 0)
     888             :                         {
     889             :                             /*
     890             :                              * didn't find a qualifying character, so remove
     891             :                              * all trailing [+-]
     892             :                              */
     893             :                             do {
     894             :                                 nchars--;
     895             :                             } while (nchars > 1 &&
     896             :                                  (yytext[nchars - 1] == '+' ||
     897             :                                   yytext[nchars - 1] == '-'));
     898             :                         }
     899             :                     }
     900             : 
     901             :                     if (nchars < yyleng)
     902             :                     {
     903             :                         /* Strip the unwanted chars from the token */
     904             :                         yyless(nchars);
     905             :                         /*
     906             :                          * If what we have left is only one char, and it's
     907             :                          * one of the characters matching "self", then
     908             :                          * return it as a character token the same way
     909             :                          * that the "self" rule would have.
     910             :                          */
     911             :                         if (nchars == 1 &&
     912             :                             strchr(",()[].;:+-*/%^<>=", yytext[0]))
     913             :                             return yytext[0];
     914             :                         /*
     915             :                          * Likewise, if what we have left is two chars, and
     916             :                          * those match the tokens ">=", "<=", "=>", "<>" or
     917             :                          * "!=", then we must return the appropriate token
     918             :                          * rather than the generic Op.
     919             :                          */
     920             :                         if (nchars == 2)
     921             :                         {
     922             :                             if (yytext[0] == '=' && yytext[1] == '>')
     923             :                                 return EQUALS_GREATER;
     924             :                             if (yytext[0] == '>' && yytext[1] == '=')
     925             :                                 return GREATER_EQUALS;
     926             :                             if (yytext[0] == '<' && yytext[1] == '=')
     927             :                                 return LESS_EQUALS;
     928             :                             if (yytext[0] == '<' && yytext[1] == '>')
     929             :                                 return NOT_EQUALS;
     930             :                             if (yytext[0] == '!' && yytext[1] == '=')
     931             :                                 return NOT_EQUALS;
     932             :                         }
     933             :                     }
     934             : 
     935             :                     base_yylval.str = mm_strdup(yytext);
     936             :                     return Op;
     937             :                 }
     938             : 
     939             : {param}         {
     940             :                     base_yylval.ival = atol(yytext+1);
     941             :                     return PARAM;
     942             :                 }
     943             : {param_junk}    {
     944             :                     mmfatal(PARSE_ERROR, "trailing junk after parameter");
     945             :                 }
     946             : 
     947             : {ip}            {
     948             :                     base_yylval.str = mm_strdup(yytext);
     949             :                     return IP;
     950             :                 }
     951             : }  /* <SQL> */
     952             : 
     953             : <C,SQL>{
     954             : {decinteger}    {
     955             :                     return process_integer_literal(yytext, &base_yylval, 10);
     956             :                 }
     957             : {hexinteger}    {
     958             :                     return process_integer_literal(yytext, &base_yylval, 16);
     959             :                 }
     960             : {numeric}       {
     961             :                     base_yylval.str = mm_strdup(yytext);
     962             :                     return FCONST;
     963             :                 }
     964             : {numericfail}   {
     965             :                     /* throw back the .., and treat as integer */
     966             :                     yyless(yyleng - 2);
     967             :                     return process_integer_literal(yytext, &base_yylval, 10);
     968             :                 }
     969             : {real}          {
     970             :                     base_yylval.str = mm_strdup(yytext);
     971             :                     return FCONST;
     972             :                 }
     973             : {realfail}      {
     974             :                     /*
     975             :                      * throw back the [Ee][+-], and figure out whether what
     976             :                      * remains is an {decinteger} or {numeric}.
     977             :                      */
     978             :                     yyless(yyleng - 2);
     979             :                     return process_integer_literal(yytext, &base_yylval, 10);
     980             :                 }
     981             : } /* <C,SQL> */
     982             : 
     983             : <SQL>{
     984             : {octinteger}    {
     985             :                     return process_integer_literal(yytext, &base_yylval, 8);
     986             :                 }
     987             : {bininteger}    {
     988             :                     return process_integer_literal(yytext, &base_yylval, 2);
     989             :                 }
     990             : 
     991             :     /*
     992             :      * Note that some trailing junk is valid in C (such as 100LL), so we
     993             :      * contain this to SQL mode.
     994             :      */
     995             : {decinteger_junk}   {
     996             :                     mmfatal(PARSE_ERROR, "trailing junk after numeric literal");
     997             :                 }
     998             : {hexinteger_junk}   {
     999             :                     mmfatal(PARSE_ERROR, "trailing junk after numeric literal");
    1000             :                 }
    1001             : {octinteger_junk}   {
    1002             :                     mmfatal(PARSE_ERROR, "trailing junk after numeric literal");
    1003             :                 }
    1004             : {bininteger_junk}   {
    1005             :                     mmfatal(PARSE_ERROR, "trailing junk after numeric literal");
    1006             :                 }
    1007             : {numeric_junk}  {
    1008             :                     mmfatal(PARSE_ERROR, "trailing junk after numeric literal");
    1009             :                 }
    1010             : {real_junk}     {
    1011             :                     mmfatal(PARSE_ERROR, "trailing junk after numeric literal");
    1012             :                 }
    1013             : 
    1014             : :{identifier}((("->"|\.){identifier})|(\[{array}\]))*  {
    1015             :                     base_yylval.str = mm_strdup(yytext+1);
    1016             :                     return CVARIABLE;
    1017             :                 }
    1018             : 
    1019             : {identifier}    {
    1020             :                     /* First check to see if it's a define symbol to expand */
    1021             :                     if (!isdefine())
    1022             :                     {
    1023             :                         int     kwvalue;
    1024             : 
    1025             :                         /*
    1026             :                          * User-defined typedefs override SQL keywords, but
    1027             :                          * not C keywords.  Currently, a typedef name is just
    1028             :                          * reported as IDENT, but someday we might need to
    1029             :                          * return a distinct token type.
    1030             :                          */
    1031             :                         if (get_typedef(yytext, true) == NULL)
    1032             :                         {
    1033             :                             /* Is it an SQL/ECPG keyword? */
    1034             :                             kwvalue = ScanECPGKeywordLookup(yytext);
    1035             :                             if (kwvalue >= 0)
    1036             :                                 return kwvalue;
    1037             :                         }
    1038             : 
    1039             :                         /* Is it a C keyword? */
    1040             :                         kwvalue = ScanCKeywordLookup(yytext);
    1041             :                         if (kwvalue >= 0)
    1042             :                             return kwvalue;
    1043             : 
    1044             :                         /*
    1045             :                          * None of the above.  Return it as an identifier.
    1046             :                          *
    1047             :                          * The backend will attempt to truncate and case-fold
    1048             :                          * the identifier, but I see no good reason for ecpg
    1049             :                          * to do so; that's just another way that ecpg could get
    1050             :                          * out of step with the backend.
    1051             :                          */
    1052             :                         base_yylval.str = mm_strdup(yytext);
    1053             :                         return IDENT;
    1054             :                     }
    1055             :                 }
    1056             : 
    1057             : {other}         {
    1058             :                     return yytext[0];
    1059             :                 }
    1060             : } /* <SQL> */
    1061             : 
    1062             :     /*
    1063             :      * Begin ECPG-specific rules
    1064             :      */
    1065             : 
    1066             : <C>{exec_sql}     { BEGIN(SQL); return SQL_START; }
    1067             : <C>{informix_special} {
    1068             :                         /* are we simulating Informix? */
    1069             :                         if (INFORMIX_MODE)
    1070             :                         {
    1071             :                             BEGIN(SQL);
    1072             :                             return SQL_START;
    1073             :                         }
    1074             :                         else
    1075             :                             return S_ANYTHING;
    1076             :                      }
    1077             : <C>{ccomment}     { ECHO; }
    1078             : <C>{cppinclude}       {
    1079             :                         if (system_includes)
    1080             :                         {
    1081             :                             include_next = false;
    1082             :                             BEGIN(incl);
    1083             :                         }
    1084             :                         else
    1085             :                         {
    1086             :                             base_yylval.str = mm_strdup(yytext);
    1087             :                             return CPP_LINE;
    1088             :                         }
    1089             :                     }
    1090             : <C>{cppinclude_next}      {
    1091             :                         if (system_includes)
    1092             :                         {
    1093             :                             include_next = true;
    1094             :                             BEGIN(incl);
    1095             :                         }
    1096             :                         else
    1097             :                         {
    1098             :                             base_yylval.str = mm_strdup(yytext);
    1099             :                             return CPP_LINE;
    1100             :                         }
    1101             :                     }
    1102             : <C,SQL>{cppline}  {
    1103             :                         base_yylval.str = mm_strdup(yytext);
    1104             :                         return CPP_LINE;
    1105             :                     }
    1106             : <C>{identifier}       {
    1107             :                         /*
    1108             :                          * Try to detect a function name:
    1109             :                          * look for identifiers at the global scope
    1110             :                          * keep the last identifier before the first '(' and '{'
    1111             :                          */
    1112             :                         if (braces_open == 0 && parenths_open == 0)
    1113             :                         {
    1114             :                             if (current_function)
    1115             :                                 free(current_function);
    1116             :                             current_function = mm_strdup(yytext);
    1117             :                         }
    1118             :                         /* Informix uses SQL defines only in SQL space */
    1119             :                         /* however, some defines have to be taken care of for compatibility */
    1120             :                         if ((!INFORMIX_MODE || !isinformixdefine()) && !isdefine())
    1121             :                         {
    1122             :                             int     kwvalue;
    1123             : 
    1124             :                             kwvalue = ScanCKeywordLookup(yytext);
    1125             :                             if (kwvalue >= 0)
    1126             :                                 return kwvalue;
    1127             :                             else
    1128             :                             {
    1129             :                                 base_yylval.str = mm_strdup(yytext);
    1130             :                                 return IDENT;
    1131             :                             }
    1132             :                         }
    1133             :                     }
    1134             : <C>{xcstop}           { mmerror(PARSE_ERROR, ET_ERROR, "nested /* ... */ comments"); }
    1135             : <C>":"              { return ':'; }
    1136             : <C>";"              { return ';'; }
    1137             : <C>","              { return ','; }
    1138             : <C>"*"              { return '*'; }
    1139             : <C>"%"              { return '%'; }
    1140             : <C>"/"              { return '/'; }
    1141             : <C>"+"              { return '+'; }
    1142             : <C>"-"              { return '-'; }
    1143             : <C>"("              { parenths_open++; return '('; }
    1144             : <C>")"              { parenths_open--; return ')'; }
    1145             : <C,xskip>{space}      { ECHO; }
    1146             : <C>\{             { return '{'; }
    1147             : <C>\}             { return '}'; }
    1148             : <C>\[             { return '['; }
    1149             : <C>\]             { return ']'; }
    1150             : <C>\=             { return '='; }
    1151             : <C>"->"              { return S_MEMBER; }
    1152             : <C>">>"               { return S_RSHIFT; }
    1153             : <C>"<<"               { return S_LSHIFT; }
    1154             : <C>"||"             { return S_OR; }
    1155             : <C>"&&"             { return S_AND; }
    1156             : <C>"++"             { return S_INC; }
    1157             : <C>"--"             { return S_DEC; }
    1158             : <C>"=="             { return S_EQUAL; }
    1159             : <C>"!="             { return S_NEQUAL; }
    1160             : <C>"+="             { return S_ADD; }
    1161             : <C>"-="             { return S_SUB; }
    1162             : <C>"*="             { return S_MUL; }
    1163             : <C>"/="             { return S_DIV; }
    1164             : <C>"%="             { return S_MOD; }
    1165             : <C>"->*"         { return S_MEMPOINT; }
    1166             : <C>".*"             { return S_DOTPOINT; }
    1167             : <C>{other}            { return S_ANYTHING; }
    1168             : <C>{exec_sql}{define}{space}* { BEGIN(def_ident); }
    1169             : <C>{informix_special}{define}{space}* {
    1170             :                         /* are we simulating Informix? */
    1171             :                         if (INFORMIX_MODE)
    1172             :                         {
    1173             :                             BEGIN(def_ident);
    1174             :                         }
    1175             :                         else
    1176             :                         {
    1177             :                             yyless(1);
    1178             :                             return S_ANYTHING;
    1179             :                         }
    1180             :                     }
    1181             : <C>{exec_sql}{undef}{space}*      { BEGIN(undef); }
    1182             : <C>{informix_special}{undef}{space}* {
    1183             :                         /* are we simulating Informix? */
    1184             :                         if (INFORMIX_MODE)
    1185             :                         {
    1186             :                             BEGIN(undef);
    1187             :                         }
    1188             :                         else
    1189             :                         {
    1190             :                             yyless(1);
    1191             :                             return S_ANYTHING;
    1192             :                         }
    1193             :                     }
    1194             : <undef>{identifier}{space}*";" {
    1195             :                     struct _defines *ptr, *ptr2 = NULL;
    1196             :                     int i;
    1197             : 
    1198             :                     /*
    1199             :                      *  Skip the ";" and trailing whitespace. Note that yytext
    1200             :                      *  contains at least one non-space character plus the ";"
    1201             :                      */
    1202             :                     for (i = strlen(yytext)-2;
    1203             :                          i > 0 && ecpg_isspace(yytext[i]);
    1204             :                          i--)
    1205             :                         ;
    1206             :                     yytext[i+1] = '\0';
    1207             : 
    1208             : 
    1209             :                     /* Find and unset any matching define; should be only 1 */
    1210             :                     for (ptr = defines; ptr; ptr2 = ptr, ptr = ptr->next)
    1211             :                     {
    1212             :                         if (strcmp(yytext, ptr->name) == 0)
    1213             :                         {
    1214             :                             free(ptr->value);
    1215             :                             ptr->value = NULL;
    1216             :                             /* We cannot forget it if there's a cmdvalue */
    1217             :                             if (ptr->cmdvalue == NULL)
    1218             :                             {
    1219             :                                 if (ptr2 == NULL)
    1220             :                                     defines = ptr->next;
    1221             :                                 else
    1222             :                                     ptr2->next = ptr->next;
    1223             :                                 free(ptr->name);
    1224             :                                 free(ptr);
    1225             :                             }
    1226             :                             break;
    1227             :                         }
    1228             :                     }
    1229             : 
    1230             :                     BEGIN(C);
    1231             :                 }
    1232             : <undef>{other}|\n {
    1233             :                         mmfatal(PARSE_ERROR, "missing identifier in EXEC SQL UNDEF command");
    1234             :                         yyterminate();
    1235             :                 }
    1236             : <C>{exec_sql}{include}{space}*    { BEGIN(incl); }
    1237             : <C>{informix_special}{include}{space}* {
    1238             :                       /* are we simulating Informix? */
    1239             :                       if (INFORMIX_MODE)
    1240             :                       {
    1241             :                           BEGIN(incl);
    1242             :                       }
    1243             :                       else
    1244             :                       {
    1245             :                           yyless(1);
    1246             :                           return S_ANYTHING;
    1247             :                       }
    1248             :                     }
    1249             : <C,xskip>{exec_sql}{ifdef}{space}* {
    1250             :                       if (preproc_tos >= MAX_NESTED_IF-1)
    1251             :                           mmfatal(PARSE_ERROR, "too many nested EXEC SQL IFDEF conditions");
    1252             :                       preproc_tos++;
    1253             :                       stacked_if_value[preproc_tos].active = false;
    1254             :                       stacked_if_value[preproc_tos].saw_active = false;
    1255             :                       stacked_if_value[preproc_tos].else_branch = false;
    1256             :                       ifcond = true;
    1257             :                       BEGIN(xcond);
    1258             :                     }
    1259             : <C,xskip>{informix_special}{ifdef}{space}* {
    1260             :                       /* are we simulating Informix? */
    1261             :                       if (INFORMIX_MODE)
    1262             :                       {
    1263             :                           if (preproc_tos >= MAX_NESTED_IF-1)
    1264             :                               mmfatal(PARSE_ERROR, "too many nested EXEC SQL IFDEF conditions");
    1265             :                           preproc_tos++;
    1266             :                           stacked_if_value[preproc_tos].active = false;
    1267             :                           stacked_if_value[preproc_tos].saw_active = false;
    1268             :                           stacked_if_value[preproc_tos].else_branch = false;
    1269             :                           ifcond = true;
    1270             :                           BEGIN(xcond);
    1271             :                       }
    1272             :                       else
    1273             :                       {
    1274             :                           yyless(1);
    1275             :                           return S_ANYTHING;
    1276             :                       }
    1277             :                     }
    1278             : <C,xskip>{exec_sql}{ifndef}{space}* {
    1279             :                       if (preproc_tos >= MAX_NESTED_IF-1)
    1280             :                           mmfatal(PARSE_ERROR, "too many nested EXEC SQL IFDEF conditions");
    1281             :                       preproc_tos++;
    1282             :                       stacked_if_value[preproc_tos].active = false;
    1283             :                       stacked_if_value[preproc_tos].saw_active = false;
    1284             :                       stacked_if_value[preproc_tos].else_branch = false;
    1285             :                       ifcond = false;
    1286             :                       BEGIN(xcond);
    1287             :                     }
    1288             : <C,xskip>{informix_special}{ifndef}{space}* {
    1289             :                       /* are we simulating Informix? */
    1290             :                       if (INFORMIX_MODE)
    1291             :                       {
    1292             :                           if (preproc_tos >= MAX_NESTED_IF-1)
    1293             :                               mmfatal(PARSE_ERROR, "too many nested EXEC SQL IFDEF conditions");
    1294             :                           preproc_tos++;
    1295             :                           stacked_if_value[preproc_tos].active = false;
    1296             :                           stacked_if_value[preproc_tos].saw_active = false;
    1297             :                           stacked_if_value[preproc_tos].else_branch = false;
    1298             :                           ifcond = false;
    1299             :                           BEGIN(xcond);
    1300             :                       }
    1301             :                       else
    1302             :                       {
    1303             :                           yyless(1);
    1304             :                           return S_ANYTHING;
    1305             :                       }
    1306             :                     }
    1307             : <C,xskip>{exec_sql}{elif}{space}* {
    1308             :                         if (preproc_tos == 0)
    1309             :                             mmfatal(PARSE_ERROR, "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"");
    1310             :                         if (stacked_if_value[preproc_tos].else_branch)
    1311             :                             mmfatal(PARSE_ERROR, "missing \"EXEC SQL ENDIF;\"");
    1312             :                         ifcond = true;
    1313             :                         BEGIN(xcond);
    1314             :                     }
    1315             : <C,xskip>{informix_special}{elif}{space}* {
    1316             :                     /* are we simulating Informix? */
    1317             :                     if (INFORMIX_MODE)
    1318             :                     {
    1319             :                         if (preproc_tos == 0)
    1320             :                             mmfatal(PARSE_ERROR, "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"");
    1321             :                         if (stacked_if_value[preproc_tos].else_branch)
    1322             :                             mmfatal(PARSE_ERROR, "missing \"EXEC SQL ENDIF;\"");
    1323             :                         ifcond = true;
    1324             :                         BEGIN(xcond);
    1325             :                     }
    1326             :                     else
    1327             :                     {
    1328             :                         yyless(1);
    1329             :                         return S_ANYTHING;
    1330             :                     }
    1331             :                 }
    1332             : 
    1333             : <C,xskip>{exec_sql}{else}{space}*";" {  /* only exec sql endif pops the stack, so take care of duplicated 'else' */
    1334             :                     if (preproc_tos == 0)
    1335             :                         mmfatal(PARSE_ERROR, "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"");
    1336             :                     else if (stacked_if_value[preproc_tos].else_branch)
    1337             :                         mmfatal(PARSE_ERROR, "more than one EXEC SQL ELSE");
    1338             :                     else
    1339             :                     {
    1340             :                         stacked_if_value[preproc_tos].else_branch = true;
    1341             :                         stacked_if_value[preproc_tos].active =
    1342             :                             (stacked_if_value[preproc_tos-1].active &&
    1343             :                              !stacked_if_value[preproc_tos].saw_active);
    1344             :                         stacked_if_value[preproc_tos].saw_active = true;
    1345             : 
    1346             :                         if (stacked_if_value[preproc_tos].active)
    1347             :                             BEGIN(C);
    1348             :                         else
    1349             :                             BEGIN(xskip);
    1350             :                     }
    1351             :                 }
    1352             : <C,xskip>{informix_special}{else}{space}*";"    {
    1353             :                     /* are we simulating Informix? */
    1354             :                     if (INFORMIX_MODE)
    1355             :                     {
    1356             :                         if (preproc_tos == 0)
    1357             :                             mmfatal(PARSE_ERROR, "missing matching \"EXEC SQL IFDEF\" / \"EXEC SQL IFNDEF\"");
    1358             :                         else if (stacked_if_value[preproc_tos].else_branch)
    1359             :                             mmfatal(PARSE_ERROR, "more than one EXEC SQL ELSE");
    1360             :                         else
    1361             :                         {
    1362             :                             stacked_if_value[preproc_tos].else_branch = true;
    1363             :                             stacked_if_value[preproc_tos].active =
    1364             :                                 (stacked_if_value[preproc_tos-1].active &&
    1365             :                                  !stacked_if_value[preproc_tos].saw_active);
    1366             :                             stacked_if_value[preproc_tos].saw_active = true;
    1367             : 
    1368             :                             if (stacked_if_value[preproc_tos].active)
    1369             :                                 BEGIN(C);
    1370             :                             else
    1371             :                                 BEGIN(xskip);
    1372             :                         }
    1373             :                     }
    1374             :                     else
    1375             :                     {
    1376             :                         yyless(1);
    1377             :                         return S_ANYTHING;
    1378             :                     }
    1379             :                 }
    1380             : <C,xskip>{exec_sql}{endif}{space}*";" {
    1381             :                     if (preproc_tos == 0)
    1382             :                         mmfatal(PARSE_ERROR, "unmatched EXEC SQL ENDIF");
    1383             :                     else
    1384             :                         preproc_tos--;
    1385             : 
    1386             :                     if (stacked_if_value[preproc_tos].active)
    1387             :                        BEGIN(C);
    1388             :                     else
    1389             :                        BEGIN(xskip);
    1390             :                 }
    1391             : <C,xskip>{informix_special}{endif}{space}*";"   {
    1392             :                     /* are we simulating Informix? */
    1393             :                     if (INFORMIX_MODE)
    1394             :                     {
    1395             :                         if (preproc_tos == 0)
    1396             :                             mmfatal(PARSE_ERROR, "unmatched EXEC SQL ENDIF");
    1397             :                         else
    1398             :                             preproc_tos--;
    1399             : 
    1400             :                         if (stacked_if_value[preproc_tos].active)
    1401             :                             BEGIN(C);
    1402             :                         else
    1403             :                             BEGIN(xskip);
    1404             :                     }
    1405             :                     else
    1406             :                     {
    1407             :                         yyless(1);
    1408             :                         return S_ANYTHING;
    1409             :                     }
    1410             :                 }
    1411             : 
    1412             : <xskip>{other}        { /* ignore */ }
    1413             : 
    1414             : <xcond>{identifier}{space}*";" {
    1415             :                     {
    1416             :                         struct _defines *defptr;
    1417             :                         unsigned int i;
    1418             :                         bool this_active;
    1419             : 
    1420             :                         /*
    1421             :                          *  Skip the ";" and trailing whitespace. Note that yytext
    1422             :                          *  contains at least one non-space character plus the ";"
    1423             :                          */
    1424             :                         for (i = strlen(yytext)-2;
    1425             :                              i > 0 && ecpg_isspace(yytext[i]);
    1426             :                              i--)
    1427             :                             ;
    1428             :                         yytext[i+1] = '\0';
    1429             : 
    1430             :                         /* Does a definition exist? */
    1431             :                         for (defptr = defines; defptr; defptr = defptr->next)
    1432             :                         {
    1433             :                             if (strcmp(yytext, defptr->name) == 0)
    1434             :                             {
    1435             :                                 /* Found it, but is it currently undefined? */
    1436             :                                 if (defptr->value == NULL)
    1437             :                                     defptr = NULL; /* pretend it's not found */
    1438             :                                 break;
    1439             :                             }
    1440             :                         }
    1441             : 
    1442             :                         this_active = (defptr ? ifcond : !ifcond);
    1443             :                         stacked_if_value[preproc_tos].active =
    1444             :                             (stacked_if_value[preproc_tos-1].active &&
    1445             :                              !stacked_if_value[preproc_tos].saw_active &&
    1446             :                              this_active);
    1447             :                         stacked_if_value[preproc_tos].saw_active |= this_active;
    1448             :                     }
    1449             : 
    1450             :                     if (stacked_if_value[preproc_tos].active)
    1451             :                         BEGIN(C);
    1452             :                     else
    1453             :                         BEGIN(xskip);
    1454             :                 }
    1455             : 
    1456             : <xcond>{other}|\n {
    1457             :                 mmfatal(PARSE_ERROR, "missing identifier in EXEC SQL IFDEF command");
    1458             :                 yyterminate();
    1459             :             }
    1460             : <def_ident>{identifier} {
    1461             :                 newdefsymbol = mm_strdup(yytext);
    1462             :                 BEGIN(def);
    1463             :                 startlit();
    1464             :             }
    1465             : <def_ident>{other}|\n {
    1466             :                 mmfatal(PARSE_ERROR, "missing identifier in EXEC SQL DEFINE command");
    1467             :                 yyterminate();
    1468             :             }
    1469             : <def>{space}*";"    {
    1470             :                         struct _defines *ptr;
    1471             : 
    1472             :                         /* Does it already exist? */
    1473             :                         for (ptr = defines; ptr != NULL; ptr = ptr->next)
    1474             :                         {
    1475             :                             if (strcmp(newdefsymbol, ptr->name) == 0)
    1476             :                             {
    1477             :                                 free(ptr->value);
    1478             :                                 ptr->value = mm_strdup(literalbuf);
    1479             :                                 /* Don't leak newdefsymbol */
    1480             :                                 free(newdefsymbol);
    1481             :                                 break;
    1482             :                             }
    1483             :                         }
    1484             :                         if (ptr == NULL)
    1485             :                         {
    1486             :                             /* Not present, make a new entry */
    1487             :                             ptr = (struct _defines *) mm_alloc(sizeof(struct _defines));
    1488             : 
    1489             :                             ptr->name = newdefsymbol;
    1490             :                             ptr->value = mm_strdup(literalbuf);
    1491             :                             ptr->cmdvalue = NULL;
    1492             :                             ptr->used = NULL;
    1493             :                             ptr->next = defines;
    1494             :                             defines = ptr;
    1495             :                         }
    1496             : 
    1497             :                         BEGIN(C);
    1498             :                     }
    1499             : <def>[^;]         { addlit(yytext, yyleng); }
    1500             : <incl>\<[^\>]+\>{space}*";"?       {   parse_include(); }
    1501             : <incl>{dquote}{xdinside}{dquote}{space}*";"?    {   parse_include(); }
    1502             : <incl>[^;\<\>\"]+";"     { parse_include(); }
    1503             : <incl>{other}|\n      {
    1504             :                     mmfatal(PARSE_ERROR, "syntax error in EXEC SQL INCLUDE command");
    1505             :                     yyterminate();
    1506             :                 }
    1507             : 
    1508             : <<EOF>>             {
    1509             :                     if (yy_buffer == NULL)
    1510             :                     {
    1511             :                         /* No more input */
    1512             :                         if (preproc_tos > 0)
    1513             :                         {
    1514             :                             preproc_tos = 0;
    1515             :                             mmfatal(PARSE_ERROR, "missing \"EXEC SQL ENDIF;\"");
    1516             :                         }
    1517             :                         yyterminate();
    1518             :                     }
    1519             :                     else
    1520             :                     {
    1521             :                         /* Revert to previous input source */
    1522             :                         struct _yy_buffer *yb = yy_buffer;
    1523             :                         int i;
    1524             :                         struct _defines *ptr;
    1525             : 
    1526             :                         /* Check to see if we are exiting a macro value */
    1527             :                         for (ptr = defines; ptr; ptr = ptr->next)
    1528             :                         {
    1529             :                             if (ptr->used == yy_buffer)
    1530             :                             {
    1531             :                                 ptr->used = NULL;
    1532             :                                 break; /* there can't be multiple matches */
    1533             :                             }
    1534             :                         }
    1535             : 
    1536             :                         if (yyin != NULL)
    1537             :                             fclose(yyin);
    1538             : 
    1539             :                         yy_delete_buffer(YY_CURRENT_BUFFER);
    1540             :                         yy_switch_to_buffer(yy_buffer->buffer);
    1541             : 
    1542             :                         yylineno = yy_buffer->lineno;
    1543             : 
    1544             :                         /* We have to output the filename only if we change files here */
    1545             :                         i = strcmp(input_filename, yy_buffer->filename);
    1546             : 
    1547             :                         free(input_filename);
    1548             :                         input_filename = yy_buffer->filename;
    1549             : 
    1550             :                         yy_buffer = yy_buffer->next;
    1551             :                         free(yb);
    1552             : 
    1553             :                         if (i != 0)
    1554             :                             output_line_number();
    1555             : 
    1556             :                     }
    1557             :                 }
    1558             : 
    1559             : <INITIAL>{other}|\n   { mmfatal(PARSE_ERROR, "internal error: unreachable state; please report this to <%s>", PACKAGE_BUGREPORT); }
    1560             : 
    1561             : %%
    1562             : 
    1563             : /* LCOV_EXCL_STOP */
    1564             : 
    1565             : void
    1566             : lex_init(void)
    1567         134 : {
    1568             :     braces_open = 0;
    1569         134 :     parenths_open = 0;
    1570         134 :     current_function = NULL;
    1571         134 : 
    1572             :     yylineno = 1;
    1573         134 : 
    1574             :     /* initialize state for if/else/endif */
    1575             :     preproc_tos = 0;
    1576         134 :     stacked_if_value[preproc_tos].active = true;
    1577         134 :     stacked_if_value[preproc_tos].saw_active = true;
    1578         134 :     stacked_if_value[preproc_tos].else_branch = false;
    1579         134 : 
    1580             :     /* initialize literal buffer to a reasonable but expansible size */
    1581             :     if (literalbuf == NULL)
    1582         134 :     {
    1583             :         literalalloc = 1024;
    1584         132 :         literalbuf = (char *) mm_alloc(literalalloc);
    1585         132 :     }
    1586             :     startlit();
    1587         134 : 
    1588             :     BEGIN(C);
    1589         134 : }
    1590         134 : 
    1591             : static void
    1592             : addlit(char *ytext, int yleng)
    1593       47902 : {
    1594             :     /* enlarge buffer if needed */
    1595             :     if ((literallen+yleng) >= literalalloc)
    1596       47902 :     {
    1597             :         do
    1598             :             literalalloc *= 2;
    1599           0 :         while ((literallen+yleng) >= literalalloc);
    1600           0 :         literalbuf = (char *) realloc(literalbuf, literalalloc);
    1601           0 :     }
    1602             :     /* append new data, add trailing null */
    1603             :     memcpy(literalbuf+literallen, ytext, yleng);
    1604       47902 :     literallen += yleng;
    1605       47902 :     literalbuf[literallen] = '\0';
    1606       47902 : }
    1607       47902 : 
    1608             : static void
    1609             : addlitchar(unsigned char ychar)
    1610           0 : {
    1611             :     /* enlarge buffer if needed */
    1612             :     if ((literallen+1) >= literalalloc)
    1613           0 :     {
    1614             :         literalalloc *= 2;
    1615           0 :         literalbuf = (char *) realloc(literalbuf, literalalloc);
    1616           0 :     }
    1617             :     /* append new data, add trailing null */
    1618             :     literalbuf[literallen] = ychar;
    1619           0 :     literallen += 1;
    1620           0 :     literalbuf[literallen] = '\0';
    1621           0 : }
    1622           0 : 
    1623             : /*
    1624             :  * Process {decinteger}, {hexinteger}, etc.  Note this will also do the right
    1625             :  * thing with {numeric}, ie digits and a decimal point.
    1626             :  */
    1627             : static int
    1628             : process_integer_literal(const char *token, YYSTYPE *lval, int base)
    1629        2386 : {
    1630             :     int         val;
    1631             :     char       *endptr;
    1632             : 
    1633             :     errno = 0;
    1634        2386 :     val = strtoint(base == 10 ? token : token + 2, &endptr, base);
    1635        2386 :     if (*endptr != '\0' || errno == ERANGE)
    1636        2386 :     {
    1637             :         /* integer too large (or contains decimal pt), treat it as a float */
    1638             :         lval->str = mm_strdup(token);
    1639          12 :         return FCONST;
    1640          12 :     }
    1641             :     lval->ival = val;
    1642        2374 :     return ICONST;
    1643        2374 : }
    1644             : 
    1645             : static void
    1646             : parse_include(void)
    1647         176 : {
    1648             :     /* got the include file name */
    1649             :     struct _yy_buffer *yb;
    1650             :     struct _include_path *ip;
    1651             :     char inc_file[MAXPGPATH];
    1652             :     unsigned int i;
    1653             : 
    1654             :     yb = mm_alloc(sizeof(struct _yy_buffer));
    1655         176 : 
    1656             :     yb->buffer = YY_CURRENT_BUFFER;
    1657         176 :     yb->lineno = yylineno;
    1658         176 :     yb->filename = input_filename;
    1659         176 :     yb->next = yy_buffer;
    1660         176 : 
    1661             :     yy_buffer = yb;
    1662         176 : 
    1663             :     /*
    1664             :      * skip the ";" if there is one and trailing whitespace. Note that
    1665             :      * yytext contains at least one non-space character plus the ";"
    1666             :      */
    1667             :     for (i = strlen(yytext)-2;
    1668         178 :          i > 0 && ecpg_isspace(yytext[i]);
    1669         178 :          i--)
    1670           2 :         ;
    1671             : 
    1672             :     if (yytext[i] == ';')
    1673         176 :         i--;
    1674           0 : 
    1675             :     yytext[i+1] = '\0';
    1676         176 : 
    1677             :     yyin = NULL;
    1678         176 : 
    1679             :     /* If file name is enclosed in '"' remove these and look only in '.' */
    1680             :     /* Informix does look into all include paths though, except filename starts with '/' */
    1681             :     if (yytext[0] == '"' && yytext[i] == '"' &&
    1682         176 :         ((compat != ECPG_COMPAT_INFORMIX && compat != ECPG_COMPAT_INFORMIX_SE) || yytext[1] == '/'))
    1683           0 :     {
    1684             :         yytext[i] = '\0';
    1685           0 :         memmove(yytext, yytext+1, strlen(yytext));
    1686           0 : 
    1687             :         strlcpy(inc_file, yytext, sizeof(inc_file));
    1688           0 :         yyin = fopen(inc_file, "r");
    1689           0 :         if (!yyin)
    1690           0 :         {
    1691             :             if (strlen(inc_file) <= 2 || strcmp(inc_file + strlen(inc_file) - 2, ".h") != 0)
    1692           0 :             {
    1693             :                 strcat(inc_file, ".h");
    1694           0 :                 yyin = fopen(inc_file, "r");
    1695           0 :             }
    1696             :         }
    1697             : 
    1698             :     }
    1699             :     else
    1700             :     {
    1701             :         if ((yytext[0] == '"' && yytext[i] == '"') || (yytext[0] == '<' && yytext[i] == '>'))
    1702         176 :         {
    1703             :             yytext[i] = '\0';
    1704           4 :             memmove(yytext, yytext+1, strlen(yytext));
    1705           4 :         }
    1706             : 
    1707             :         for (ip = include_paths; yyin == NULL && ip != NULL; ip = ip->next)
    1708         478 :         {
    1709             :             if (strlen(ip->path) + strlen(yytext) + 4 > MAXPGPATH)
    1710         302 :             {
    1711             :                 fprintf(stderr, _("Error: include path \"%s/%s\" is too long on line %d, skipping\n"), ip->path, yytext, yylineno);
    1712           0 :                 continue;
    1713           0 :             }
    1714             :             snprintf (inc_file, sizeof(inc_file), "%s/%s", ip->path, yytext);
    1715         302 :             yyin = fopen(inc_file, "r");
    1716         302 :             if (!yyin)
    1717         302 :             {
    1718             :                 if (strcmp(inc_file + strlen(inc_file) - 2, ".h") != 0)
    1719         278 :                 {
    1720             :                     strcat(inc_file, ".h");
    1721         272 :                     yyin = fopen(inc_file, "r");
    1722         272 :                 }
    1723             :             }
    1724             :             /* if the command was "include_next" we have to disregard the first hit */
    1725             :             if (yyin && include_next)
    1726         302 :             {
    1727             :                 fclose (yyin);
    1728           0 :                 yyin = NULL;
    1729           0 :                 include_next = false;
    1730           0 :             }
    1731             :         }
    1732             :     }
    1733             :     if (!yyin)
    1734         176 :         mmfatal(NO_INCLUDE_FILE, "could not open include file \"%s\" on line %d", yytext, yylineno);
    1735           0 : 
    1736             :     input_filename = mm_strdup(inc_file);
    1737         176 :     yy_switch_to_buffer(yy_create_buffer(yyin,YY_BUF_SIZE));
    1738         176 :     yylineno = 1;
    1739         176 :     output_line_number();
    1740         176 : 
    1741             :     BEGIN(C);
    1742         176 : }
    1743         176 : 
    1744             : /*
    1745             :  * ecpg_isspace() --- return true if flex scanner considers char whitespace
    1746             :  */
    1747             : static bool
    1748             : ecpg_isspace(char ch)
    1749         210 : {
    1750             :     if (ch == ' ' ||
    1751         210 :         ch == '\t' ||
    1752         210 :         ch == '\n' ||
    1753         208 :         ch == '\r' ||
    1754         208 :         ch == '\f' ||
    1755         208 :         ch == '\v')
    1756             :         return true;
    1757           2 :     return false;
    1758         208 : }
    1759             : 
    1760             : /*
    1761             :  * If yytext matches a define symbol, begin scanning the symbol's value
    1762             :  * and return true
    1763             :  */
    1764             : static bool
    1765             : isdefine(void)
    1766       28118 : {
    1767             :     struct _defines *ptr;
    1768             : 
    1769             :     /* is it a define? */
    1770             :     for (ptr = defines; ptr; ptr = ptr->next)
    1771      128258 :     {
    1772             :         /* notice we do not match anything being actively expanded */
    1773             :         if (strcmp(yytext, ptr->name) == 0 &&
    1774      100308 :             ptr->value != NULL &&
    1775         168 :             ptr->used == NULL)
    1776         168 :         {
    1777             :             /* Save state associated with the current buffer */
    1778             :             struct _yy_buffer *yb;
    1779             : 
    1780             :             yb = mm_alloc(sizeof(struct _yy_buffer));
    1781         168 : 
    1782             :             yb->buffer =  YY_CURRENT_BUFFER;
    1783         168 :             yb->lineno = yylineno;
    1784         168 :             yb->filename = mm_strdup(input_filename);
    1785         168 :             yb->next = yy_buffer;
    1786         168 :             yy_buffer = yb;
    1787         168 : 
    1788             :             /* Mark symbol as being actively expanded */
    1789             :             ptr->used = yb;
    1790         168 : 
    1791             :             /*
    1792             :              * We use yy_scan_string which will copy the value, so there's
    1793             :              * no need to worry about a possible undef happening while we
    1794             :              * are still scanning it.
    1795             :              */
    1796             :             yy_scan_string(ptr->value);
    1797         168 :             return true;
    1798         168 :         }
    1799             :     }
    1800             : 
    1801             :     return false;
    1802       27950 : }
    1803             : 
    1804             : /*
    1805             :  * Handle replacement of INFORMIX built-in defines.  This works just
    1806             :  * like isdefine() except for the source of the string to scan.
    1807             :  */
    1808             : static bool
    1809             : isinformixdefine(void)
    1810        3518 : {
    1811             :     const char *new = NULL;
    1812        3518 : 
    1813             :     if (strcmp(yytext, "dec_t") == 0)
    1814        3518 :         new = "decimal";
    1815           2 :     else if (strcmp(yytext, "intrvl_t") == 0)
    1816        3516 :         new = "interval";
    1817           0 :     else if (strcmp(yytext, "dtime_t") == 0)
    1818        3516 :         new = "timestamp";
    1819           0 : 
    1820             :     if (new)
    1821        3518 :     {
    1822             :         struct _yy_buffer *yb;
    1823             : 
    1824             :         yb = mm_alloc(sizeof(struct _yy_buffer));
    1825           2 : 
    1826             :         yb->buffer =  YY_CURRENT_BUFFER;
    1827           2 :         yb->lineno = yylineno;
    1828           2 :         yb->filename = mm_strdup(input_filename);
    1829           2 :         yb->next = yy_buffer;
    1830           2 :         yy_buffer = yb;
    1831           2 : 
    1832             :         yy_scan_string(new);
    1833           2 :         return true;
    1834           2 :     }
    1835             : 
    1836             :     return false;
    1837        3516 : }

Generated by: LCOV version 1.14