LCOV - code coverage report
Current view: top level - src/backend/replication - repl_scanner.l (source / functions) Hit Total Coverage
Test: PostgreSQL 12beta1 Lines: 17 28 60.7 %
Date: 2019-06-16 14:06:46 Functions: 4 8 50.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : %{
       2             : /*-------------------------------------------------------------------------
       3             :  *
       4             :  * repl_scanner.l
       5             :  *    a lexical scanner for the replication commands
       6             :  *
       7             :  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
       8             :  * Portions Copyright (c) 1994, Regents of the University of California
       9             :  *
      10             :  *
      11             :  * IDENTIFICATION
      12             :  *    src/backend/replication/repl_scanner.l
      13             :  *
      14             :  *-------------------------------------------------------------------------
      15             :  */
      16             : #include "postgres.h"
      17             : 
      18             : #include "utils/builtins.h"
      19             : #include "parser/scansup.h"
      20             : 
      21             : /* Avoid exit() on fatal scanner errors (a bit ugly -- see yy_fatal_error) */
      22             : #undef fprintf
      23             : #define fprintf(file, fmt, msg)  fprintf_to_ereport(fmt, msg)
      24             : 
      25             : static void
      26           0 : fprintf_to_ereport(const char *fmt, const char *msg)
      27             : {
      28           0 :     ereport(ERROR, (errmsg_internal("%s", msg)));
      29             : }
      30             : 
      31             : /* Handle to the buffer that the lexer uses internally */
      32             : static YY_BUFFER_STATE scanbufhandle;
      33             : 
      34             : static StringInfoData litbuf;
      35             : 
      36             : static void startlit(void);
      37             : static char *litbufdup(void);
      38             : static void addlit(char *ytext, int yleng);
      39             : static void addlitchar(unsigned char ychar);
      40             : 
      41             : /* LCOV_EXCL_START */
      42             : 
      43             : %}
      44             : 
      45             : %option 8bit
      46             : %option never-interactive
      47             : %option nodefault
      48             : %option noinput
      49             : %option nounput
      50             : %option noyywrap
      51             : %option warn
      52             : %option prefix="replication_yy"
      53             : 
      54             : %x xq xd
      55             : 
      56             : /* Extended quote
      57             :  * xqdouble implements embedded quote, ''''
      58             :  */
      59             : xqstart         {quote}
      60             : xqdouble        {quote}{quote}
      61             : xqinside        [^']+
      62             : 
      63             : /* Double quote
      64             :  * Allows embedded spaces and other special characters into identifiers.
      65             :  */
      66             : dquote          \"
      67             : xdstart         {dquote}
      68             : xdstop          {dquote}
      69             : xddouble        {dquote}{dquote}
      70             : xdinside        [^"]+
      71             : 
      72             : digit           [0-9]+
      73             : hexdigit        [0-9A-Za-z]+
      74             : 
      75             : quote           '
      76             : quotestop       {quote}
      77             : 
      78             : ident_start     [A-Za-z\200-\377_]
      79             : ident_cont      [A-Za-z\200-\377_0-9\$]
      80             : 
      81             : identifier      {ident_start}{ident_cont}*
      82             : 
      83             : %%
      84             : 
      85             : BASE_BACKUP         { return K_BASE_BACKUP; }
      86             : FAST            { return K_FAST; }
      87             : IDENTIFY_SYSTEM     { return K_IDENTIFY_SYSTEM; }
      88             : SHOW        { return K_SHOW; }
      89             : LABEL           { return K_LABEL; }
      90             : NOWAIT          { return K_NOWAIT; }
      91             : PROGRESS            { return K_PROGRESS; }
      92             : MAX_RATE        { return K_MAX_RATE; }
      93             : WAL         { return K_WAL; }
      94             : TABLESPACE_MAP          { return K_TABLESPACE_MAP; }
      95             : NOVERIFY_CHECKSUMS  { return K_NOVERIFY_CHECKSUMS; }
      96             : TIMELINE            { return K_TIMELINE; }
      97             : START_REPLICATION   { return K_START_REPLICATION; }
      98             : CREATE_REPLICATION_SLOT     { return K_CREATE_REPLICATION_SLOT; }
      99             : DROP_REPLICATION_SLOT       { return K_DROP_REPLICATION_SLOT; }
     100             : TIMELINE_HISTORY    { return K_TIMELINE_HISTORY; }
     101             : PHYSICAL            { return K_PHYSICAL; }
     102             : RESERVE_WAL         { return K_RESERVE_WAL; }
     103             : LOGICAL             { return K_LOGICAL; }
     104             : SLOT                { return K_SLOT; }
     105             : TEMPORARY           { return K_TEMPORARY; }
     106             : EXPORT_SNAPSHOT     { return K_EXPORT_SNAPSHOT; }
     107             : NOEXPORT_SNAPSHOT   { return K_NOEXPORT_SNAPSHOT; }
     108             : USE_SNAPSHOT        { return K_USE_SNAPSHOT; }
     109             : WAIT                { return K_WAIT; }
     110             : 
     111             : ","               { return ','; }
     112             : ";"               { return ';'; }
     113             : "("               { return '('; }
     114             : ")"               { return ')'; }
     115             : 
     116             : [\n]            ;
     117             : [\t]            ;
     118             : " "               ;
     119             : 
     120             : {digit}+        {
     121             :                     yylval.uintval = strtoul(yytext, NULL, 10);
     122             :                     return UCONST;
     123             :                 }
     124             : 
     125             : {hexdigit}+\/{hexdigit}+        {
     126             :                     uint32  hi,
     127             :                             lo;
     128             :                     if (sscanf(yytext, "%X/%X", &hi, &lo) != 2)
     129             :                         yyerror("invalid streaming start location");
     130             :                     yylval.recptr = ((uint64) hi) << 32 | lo;
     131             :                     return RECPTR;
     132             :                 }
     133             : 
     134             : {xqstart}       {
     135             :                     BEGIN(xq);
     136             :                     startlit();
     137             :                 }
     138             : 
     139             : <xq>{quotestop}   {
     140             :                     yyless(1);
     141             :                     BEGIN(INITIAL);
     142             :                     yylval.str = litbufdup();
     143             :                     return SCONST;
     144             :                 }
     145             : 
     146             : <xq>{xqdouble}    {
     147             :                     addlitchar('\'');
     148             :                 }
     149             : 
     150             : <xq>{xqinside}  {
     151             :                     addlit(yytext, yyleng);
     152             :                 }
     153             : 
     154             : {xdstart}       {
     155             :                     BEGIN(xd);
     156             :                     startlit();
     157             :                 }
     158             : 
     159             : <xd>{xdstop}  {
     160             :                     int len;
     161             :                     yyless(1);
     162             :                     BEGIN(INITIAL);
     163             :                     yylval.str = litbufdup();
     164             :                     len = strlen(yylval.str);
     165             :                     truncate_identifier(yylval.str, len, true);
     166             :                     return IDENT;
     167             :                 }
     168             : 
     169             : <xd>{xdinside}  {
     170             :                     addlit(yytext, yyleng);
     171             :                 }
     172             : 
     173             : {identifier}    {
     174             :                     int len = strlen(yytext);
     175             : 
     176             :                     yylval.str = downcase_truncate_identifier(yytext, len, true);
     177             :                     return IDENT;
     178             :                 }
     179             : 
     180             : <xq,xd><<EOF>>    { yyerror("unterminated quoted string"); }
     181             : 
     182             : 
     183             : <<EOF>>         {
     184             :                     yyterminate();
     185             :                 }
     186             : 
     187             : .               {
     188             :                     return T_WORD;
     189             :                 }
     190             : %%
     191             : 
     192             : /* LCOV_EXCL_STOP */
     193             : 
     194             : static void
     195             : startlit(void)
     196         870 : {
     197             :     initStringInfo(&litbuf);
     198         870 : }
     199         870 : 
     200             : static char *
     201             : litbufdup(void)
     202         870 : {
     203             :     return litbuf.data;
     204         870 : }
     205             : 
     206             : static void
     207             : addlit(char *ytext, int yleng)
     208         788 : {
     209             :     appendBinaryStringInfo(&litbuf, ytext, yleng);
     210         788 : }
     211         788 : 
     212             : static void
     213             : addlitchar(unsigned char ychar)
     214           0 : {
     215             :     appendStringInfoChar(&litbuf, ychar);
     216           0 : }
     217           0 : 
     218             : void
     219             : yyerror(const char *message)
     220           0 : {
     221             :     ereport(ERROR,
     222           0 :             (errcode(ERRCODE_SYNTAX_ERROR),
     223             :              errmsg_internal("%s", message)));
     224             : }
     225             : 
     226             : 
     227             : void
     228             : replication_scanner_init(const char *str)
     229        1608 : {
     230             :     Size        slen = strlen(str);
     231        1608 :     char       *scanbuf;
     232             : 
     233             :     /*
     234             :      * Might be left over after ereport()
     235             :      */
     236             :     if (YY_CURRENT_BUFFER)
     237        1608 :         yy_delete_buffer(YY_CURRENT_BUFFER);
     238        1146 : 
     239             :     /*
     240             :      * Make a scan buffer with special termination needed by flex.
     241             :      */
     242             :     scanbuf = (char *) palloc(slen + 2);
     243        1608 :     memcpy(scanbuf, str, slen);
     244        1608 :     scanbuf[slen] = scanbuf[slen + 1] = YY_END_OF_BUFFER_CHAR;
     245        1608 :     scanbufhandle = yy_scan_buffer(scanbuf, slen + 2);
     246        1608 : }
     247        1608 : 
     248             : void
     249             : replication_scanner_finish(void)
     250           0 : {
     251             :     yy_delete_buffer(scanbufhandle);
     252           0 :     scanbufhandle = NULL;
     253           0 : }

Generated by: LCOV version 1.13