Branch data     Line data    Source code

       1                 :             : %top{
       2                 :             : /*
       3                 :             :  * A scanner for EMP-style numeric ranges
       4                 :             :  * contrib/cube/cubescan.l
       5                 :             :  */
       6                 :             : 
       7                 :             : #include "postgres.h"
       8                 :             : 
       9                 :             : #include "cubedata.h"
      10                 :             : #include "cubeparse.h"    /* must be after cubedata.h for YYSTYPE and NDBOX */
      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="cube_yy"
      43                 :             : 
      44                 :             : 
      45                 :             : n            [0-9]+
      46                 :             : integer      [+-]?{n}
      47                 :             : real         [+-]?({n}\.{n}?|\.{n})
      48                 :             : float        ({integer}|{real})([eE]{integer})?
      49                 :             : infinity     [+-]?[iI][nN][fF]([iI][nN][iI][tT][yY])?
      50                 :             : NaN          [nN][aA][nN]
      51                 :             : 
      52                 :             : %%
      53                 :             : 
      54                 :       14058 : {float}      *yylval = yytext; return CUBEFLOAT;
      55                 :           2 : {infinity}   *yylval = yytext; return CUBEFLOAT;
      56                 :           2 : {NaN}        *yylval = yytext; return CUBEFLOAT;
      57                 :           1 : \[           *yylval = "("; return O_BRACKET;
      58                 :          23 : \]           *yylval = ")"; return C_BRACKET;
      59                 :          21 : \(           *yylval = "("; return O_PAREN;
      60                 :        6604 : \)           *yylval = ")"; return C_PAREN;
      61                 :        6602 : \,           *yylval = ","; return COMMA;
      62                 :       10645 : [ \t\n\r\f\v]+ /* discard spaces */
      63                 :          39 : .            return yytext[0]; /* alert parser of the garbage */
      64                 :           6 : 
      65                 :           0 : %%
      66                 :             : 
      67                 :             : /* LCOV_EXCL_STOP */
      68                 :             : 
      69                 :             : /* result and scanbuflen are not used, but Bison expects this signature */
      70                 :             : void
      71                 :          24 : cube_yyerror(NDBOX **result, Size scanbuflen,
      72                 :             :              struct Node *escontext,
      73                 :             :              yyscan_t yyscanner,
      74                 :             :              const char *message)
      75                 :             : {
      76                 :          24 :     struct yyguts_t *yyg = (struct yyguts_t *) yyscanner;   /* needed for yytext
      77                 :             :                                                              * macro */
      78                 :             : 
      79         [ +  + ]:          24 :     if (*yytext == YY_END_OF_BUFFER_CHAR)
      80                 :             :     {
      81         [ +  - ]:           3 :         errsave(escontext,
      82                 :             :                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
      83                 :             :                  errmsg("invalid input syntax for cube"),
      84                 :             :         /* translator: %s is typically "syntax error" */
      85                 :             :                  errdetail("%s at end of input", message)));
      86                 :             :     }
      87                 :             :     else
      88                 :             :     {
      89         [ +  + ]:          21 :         errsave(escontext,
      90                 :             :                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
      91                 :             :                  errmsg("invalid input syntax for cube"),
      92                 :             :         /* translator: first %s is typically "syntax error" */
      93                 :             :                  errdetail("%s at or near \"%s\"", message, yytext)));
      94                 :             :     }
      95                 :           1 : }
      96                 :             : 
      97                 :             : 
      98                 :             : /*
      99                 :             :  * Called before any actual parsing is done
     100                 :             :  */
     101                 :             : void
     102                 :        3435 : cube_scanner_init(const char *str, Size *scanbuflen, yyscan_t *yyscannerp)
     103                 :             : {
     104                 :        3435 :     Size        slen = strlen(str);
     105                 :             :     yyscan_t    yyscanner;
     106                 :             : 
     107         [ -  + ]:        3435 :     if (yylex_init(yyscannerp) != 0)
     108         [ #  # ]:           0 :         elog(ERROR, "yylex_init() failed: %m");
     109                 :             : 
     110                 :        3435 :     yyscanner = *yyscannerp;
     111                 :             : 
     112                 :        3435 :     yy_scan_bytes(str, slen, yyscanner);
     113                 :        3435 :     *scanbuflen = slen;
     114                 :        3435 : }
     115                 :             : 
     116                 :             : 
     117                 :             : /*
     118                 :             :  * Called after parsing is done to clean up after cube_scanner_init()
     119                 :             :  */
     120                 :             : void
     121                 :        3405 : cube_scanner_finish(yyscan_t yyscanner)
     122                 :             : {
     123                 :        3405 :     yylex_destroy(yyscanner);
     124                 :        3405 : }
     125                 :             : 
     126                 :             : /*
     127                 :             :  * Interface functions to make flex use palloc() instead of malloc().
     128                 :             :  * It'd be better to make these static, but flex insists otherwise.
     129                 :             :  */
     130                 :             : 
     131                 :             : void *
     132                 :       13740 : yyalloc(yy_size_t size, yyscan_t yyscanner)
     133                 :             : {
     134                 :       13740 :     return palloc(size);
     135                 :             : }
     136                 :             : 
     137                 :             : void *
     138                 :           0 : yyrealloc(void *ptr, yy_size_t size, yyscan_t yyscanner)
     139                 :             : {
     140         [ #  # ]:           0 :     if (ptr)
     141                 :           0 :         return repalloc(ptr, size);
     142                 :             :     else
     143                 :           0 :         return palloc(size);
     144                 :             : }
     145                 :             : 
     146                 :             : void
     147                 :       17025 : yyfree(void *ptr, yyscan_t yyscanner)
     148                 :             : {
     149         [ +  + ]:       17025 :     if (ptr)
     150                 :       13620 :         pfree(ptr);
     151                 :       17025 : }