Branch data     Line data    Source code

       1                 :             : %top{
       2                 :             : /*
       3                 :             :  * A scanner for EMP-style numeric ranges
       4                 :             :  */
       5                 :             : #include "postgres.h"
       6                 :             : 
       7                 :             : #include "nodes/miscnodes.h"
       8                 :             : 
       9                 :             : #include "segdata.h"
      10                 :             : #include "segparse.h" /* must be after segdata.h for SEG */
      11                 :             : }
      12                 :             : 
      13                 :             : %{
      14                 :             : /* LCOV_EXCL_START */
      15                 :             : 
      16                 :             : /* No reason to constrain amount of data slurped */
      17                 :             : #define YY_READ_BUF_SIZE 16777216
      18                 :             : 
      19                 :             : /* Avoid exit() on fatal scanner errors (a bit ugly -- see yy_fatal_error) */
      20                 :             : #undef fprintf
      21                 :             : #define fprintf(file, fmt, msg)  fprintf_to_ereport(fmt, msg)
      22                 :             : 
      23                 :             : static void
      24                 :           0 : fprintf_to_ereport(const char *fmt, const char *msg)
      25                 :             : {
      26         [ #  # ]:           0 :     ereport(ERROR, (errmsg_internal("%s", msg)));
      27                 :             : }
      28                 :             : %}
      29                 :             : 
      30                 :             : %option reentrant
      31                 :             : %option bison-bridge
      32                 :             : %option 8bit
      33                 :             : %option never-interactive
      34                 :             : %option nodefault
      35                 :             : %option noinput
      36                 :             : %option nounput
      37                 :             : %option noyywrap
      38                 :             : %option noyyalloc
      39                 :             : %option noyyrealloc
      40                 :             : %option noyyfree
      41                 :             : %option warn
      42                 :             : %option prefix="seg_yy"
      43                 :             : 
      44                 :             : 
      45                 :             : range        (\.\.)(\.)?
      46                 :             : plumin       (\'\+\-\')|(\(\+\-)\)
      47                 :             : integer      [+-]?[0-9]+
      48                 :             : real         [+-]?[0-9]+\.[0-9]+
      49                 :             : float        ({integer}|{real})([eE]{integer})?
      50                 :             : 
      51                 :             : %%
      52                 :             : 
      53                 :        2456 : {range}      yylval->text = yytext; return RANGE;
      54                 :           7 : {plumin}     yylval->text = yytext; return PLUMIN;
      55                 :           7 : {float}      yylval->text = yytext; return SEGFLOAT;
      56                 :        5192 : \<           yylval->text = "<"; return EXTENSION;
      57                 :         532 : \>           yylval->text = ">"; return EXTENSION;
      58                 :         674 : \~           yylval->text = "~"; return EXTENSION;
      59                 :          19 : [ \t\n\r\f\v]+ /* discard spaces */
      60                 :         504 : .            return yytext[0]; /* alert parser of the garbage */
      61                 :          10 : 
      62                 :           0 : %%
      63                 :             : 
      64                 :             : /* LCOV_EXCL_STOP */
      65                 :             : 
      66                 :             : void
      67                 :          22 : seg_yyerror(SEG *result, struct Node *escontext, yyscan_t yyscanner, const char *message)
      68                 :             : {
      69                 :          22 :     struct yyguts_t *yyg = (struct yyguts_t *) yyscanner;   /* needed for yytext
      70                 :             :                                                              * macro */
      71                 :             : 
      72                 :             :     /* if we already reported an error, don't overwrite it */
      73   [ +  +  +  -  :          22 :     if (SOFT_ERROR_OCCURRED(escontext))
                   +  + ]
      74                 :           8 :         return;
      75                 :             : 
      76         [ +  + ]:          14 :     if (*yytext == YY_END_OF_BUFFER_CHAR)
      77                 :             :     {
      78         [ +  + ]:           3 :         errsave(escontext,
      79                 :             :                 (errcode(ERRCODE_SYNTAX_ERROR),
      80                 :             :                  errmsg("bad seg representation"),
      81                 :             :         /* translator: %s is typically "syntax error" */
      82                 :             :                  errdetail("%s at end of input", message)));
      83                 :             :     }
      84                 :             :     else
      85                 :             :     {
      86         [ +  + ]:          11 :         errsave(escontext,
      87                 :             :                 (errcode(ERRCODE_SYNTAX_ERROR),
      88                 :             :                  errmsg("bad seg representation"),
      89                 :             :         /* translator: first %s is typically "syntax error" */
      90                 :             :                  errdetail("%s at or near \"%s\"", message, yytext)));
      91                 :             :     }
      92                 :             : }
      93                 :             : 
      94                 :             : 
      95                 :             : /*
      96                 :             :  * Called before any actual parsing is done
      97                 :             :  */
      98                 :             : void
      99                 :        2832 : seg_scanner_init(const char *str, yyscan_t *yyscannerp)
     100                 :             : {
     101                 :             :     yyscan_t    yyscanner;
     102                 :             : 
     103         [ -  + ]:        2832 :     if (yylex_init(yyscannerp) != 0)
     104         [ #  # ]:           0 :         elog(ERROR, "yylex_init() failed: %m");
     105                 :             : 
     106                 :        2832 :     yyscanner = *yyscannerp;
     107                 :             : 
     108                 :        2832 :     yy_scan_string(str, yyscanner);
     109                 :        2832 : }
     110                 :             : 
     111                 :             : 
     112                 :             : /*
     113                 :             :  * Called after parsing is done to clean up after seg_scanner_init()
     114                 :             :  */
     115                 :             : void
     116                 :        2823 : seg_scanner_finish(yyscan_t yyscanner)
     117                 :             : {
     118                 :        2823 :     yylex_destroy(yyscanner);
     119                 :        2823 : }
     120                 :             : 
     121                 :             : /*
     122                 :             :  * Interface functions to make flex use palloc() instead of malloc().
     123                 :             :  * It'd be better to make these static, but flex insists otherwise.
     124                 :             :  */
     125                 :             : 
     126                 :             : void *
     127                 :       11328 : yyalloc(yy_size_t size, yyscan_t yyscanner)
     128                 :             : {
     129                 :       11328 :     return palloc(size);
     130                 :             : }
     131                 :             : 
     132                 :             : void *
     133                 :           0 : yyrealloc(void *ptr, yy_size_t size, yyscan_t yyscanner)
     134                 :             : {
     135         [ #  # ]:           0 :     if (ptr)
     136                 :           0 :         return repalloc(ptr, size);
     137                 :             :     else
     138                 :           0 :         return palloc(size);
     139                 :             : }
     140                 :             : 
     141                 :             : void
     142                 :       14115 : yyfree(void *ptr, yyscan_t yyscanner)
     143                 :             : {
     144         [ +  + ]:       14115 :     if (ptr)
     145                 :       11292 :         pfree(ptr);
     146                 :       14115 : }