src/ftacmp/fta.l

   1 /* ------------------------------------------------
   2 Copyright 2020 AT&T Intellectual Property
   3    Licensed under the Apache License, Version 2.0 (the "License");
   4    you may not use this file except in compliance with the License.
   5    You may obtain a copy of the License at
   6
   7      http://www.apache.org/licenses/LICENSE-2.0
   8
   9    Unless required by applicable law or agreed to in writing, software
  10    distributed under the License is distributed on an "AS IS" BASIS,
  11    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12    See the License for the specific language governing permissions and
  13    limitations under the License.
  14  ------------------------------------------- */
  15
  16
  17 /*
  18         MUST COMPILE WITH
  19                 flex -PFtaParser -oftalexer.cc fta.l
  20         (or equivalent).
  21 */
  22
  23 %{
  24 /*
  25  * AT&T lex can't handle this lexer due to lex bugs.  It works with flex
  26  * 2.3.7, pclex 2.0.5, and MKS lex 3.1a.
  27  */
  28
  29  #include "parse_fta.h"
  30  #include "parse_schema.h"
  31  #include <string.h>
  32
  33
  34
  35 #include "fta.tab.cc.h"
  36
  37 /*
  38         Some includes that flex doesn't include as standard,
  39         but which are needed.
  40 */
  41
  42 #include <stdlib.h>
  43 #include <string.h>
  44
  45
  46 //              Prevent flex from defining yywrap as extern "C"
  47
  48 #define YY_SKIP_YYWRAP
  49
  50 /*              No lex lib, supply the yywrap fcn. that normally resides there
  51 */
  52
  53 //int FtaParserwrap(){return(1);}
  54
  55 extern int FtaParserdebug;
  56
  57
  58 /*
  59                 These variables are used for error reporting:
  60                 flex_fta_lineno : the line currently being parsed when the error occurs.
  61                 flex_fta_ch : the character on the line where the error occurs
  62                 flex_fta_linebuf : store the line for reporting.
  63
  64                 NOTE : 1) the fixed size flex_fta_linebuf buffer is dangerous.
  65                            2) You might get pointed to a place shortly after
  66                                   where the syntax error occurs.  It is close enough
  67                                   for now.
  68 */
  69
  70 int flex_fta_lineno = 1;
  71 int flex_fta_ch = 0;
  72 char flex_fta_linebuf[200000];
  73
  74 char *flex_fta_stringinput = NULL;
  75 int flex_fta_stringinput_ptr = 0;
  76 FILE *flex_fta_fileinput = NULL;
  77 int my_FtaParser_yyinput(char *buf, int max_size);
  78
  79
  80
  81 void FtaParsererror(char *s){
  82         int i;
  83         fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n",
  84                                 flex_fta_lineno, flex_fta_ch, s, FtaParsertext, flex_fta_linebuf );
  85     for(i=0;i<flex_fta_ch;i++){
  86                 if(flex_fta_linebuf[i] == '\t'){
  87                         fprintf(stderr,"\t");
  88                 }else{
  89                         fprintf(stderr," ");
  90                 }
  91         }
  92         fprintf(stderr,"^\n");
  93         //      fprintf(stderr,"%*s\n",1+flex_fta_ch,"^");
  94 }
  95
  96 #undef YY_INPUT
  97 #define YY_INPUT(b, r, ms) (r = my_FtaParser_yyinput(b,ms))
  98
  99 %}
 100         /* MKS needs the next line to increase the NFA table */
 101 %e 1200
 102 %option noyywrap
 103
 104 %%
 105
 106         /* literal keyword tokens */
 107
 108  /*
 109                         The actions associated with each text token are to
 110                         keep track of the current location (for syntax error reporting)
 111                         and to report any necessary info to the emf.y parse tree builder
 112
 113                         Its likely that there are a number of omissions, inconsistencies
 114                         (some keywords do not need to be in caps), and relics
 115                         (keywords such as BETWEEN, INDICATOR, etc., are not used
 116                          in emf.y)
 117                         This parser is somewhat of a work in progress.
 118  */
 119
 120  /*             Query keywords          */
 121
 122 AND|And|and             { flex_fta_ch+=FtaParserleng; return AND; }
 123 AND_AGGR|And_Aggr|and_aggr              { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("AND_AGGR"); return AGGR; }
 124 OR_AGGR|Or_Aggr|or_aggr         { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("OR_AGGR"); return AGGR; }
 125 XOR_AGGR|Xor_Aggr|xor_aggr              { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("XOR_AGGR"); return AGGR; }
 126 AVG|Avg|avg             { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("AVG"); return AGGR; }
 127 MIN|Min|min             { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("MIN"); return AGGR; }
 128 MAX|Max|max             { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("MAX"); return AGGR; }
 129 SUM|Sum|sum             { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("SUM"); return AGGR; }
 130 COUNT|Count|count       { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup("COUNT"); return AGGR; }
 131 BY|By|by                { flex_fta_ch+=FtaParserleng; return BY; }
 132 FROM|From|from          { flex_fta_ch+=FtaParserleng; return FROM; }
 133 INNER_JOIN|Inner_Join|inner_join        { flex_fta_ch+=FtaParserleng; return INNER_JOIN; }
 134 OUTER_JOIN|Outer_Join|outer_join        { flex_fta_ch+=FtaParserleng; return OUTER_JOIN; }
 135 RIGHT_OUTER_JOIN|Right_Outer_Join|right_outer_join      { flex_fta_ch+=FtaParserleng; return RIGHT_OUTER_JOIN; }
 136 LEFT_OUTER_JOIN|Left_Outer_Join|left_outer_join { flex_fta_ch+=FtaParserleng; return LEFT_OUTER_JOIN; }
 137 WATCHLIST_JOIN|Watchlist_Join|watchlist_join    { flex_fta_ch+=FtaParserleng; return WATCHLIST_JOIN; }
 138 FILTER_JOIN|Filter_Join|filter_join     { flex_fta_ch+=FtaParserleng; return FILTER_JOIN; }
 139 GROUP|Group|group       { flex_fta_ch+=FtaParserleng; return GROUP; }
 140 ROLLUP|Rollup|rollup    { flex_fta_ch+=FtaParserleng; return ROLLUP; }
 141 CUBE|Cube|cube  { flex_fta_ch+=FtaParserleng; return CUBE; }
 142 GROUPING_SETS|Grouping_Sets|grouping_sets       { flex_fta_ch+=FtaParserleng; return GROUPING_SETS; }
 143 SUPERGROUP|Supergroup|supergroup        { flex_fta_ch+=FtaParserleng; return SUPERGROUP; }
 144 CLEANING_WHEN|Cleaning_When|cleaning_when       { flex_fta_ch+=FtaParserleng; return CLEANING_WHEN; }
 145 CLEANING_BY|Cleaning_By|cleaning_by     { flex_fta_ch+=FtaParserleng; return CLEANING_BY; }
 146 CLOSING_WHEN|Closing_When|closing_when  { flex_fta_ch+=FtaParserleng; return CLOSING_WHEN; }
 147 HAVING|Having|having    { flex_fta_ch+=FtaParserleng; return HAVING; }
 148 AS|As|as                { flex_fta_ch+=FtaParserleng; return AS; }
 149 IN|In|in                { flex_fta_ch+=FtaParserleng; return IN; }
 150 NOT|Not|not             { flex_fta_ch+=FtaParserleng; return NOT; }
 151 OR|Or|or        { flex_fta_ch+=FtaParserleng; return OR; }
 152
 153 SELECT|Select|select            { flex_fta_ch+=FtaParserleng; return SELECT; }
 154 WHERE|Where|where               { flex_fta_ch+=FtaParserleng; return WHERE; }
 155 SUCH|Such|such  { flex_fta_ch+=FtaParserleng; return SUCH;}
 156 THAT|That|that  { flex_fta_ch+=FtaParserleng; return THAT;}
 157 MERGE|Merge|merge        {flex_fta_ch+=FtaParserleng; return MERGE;}
 158 SLACK    {flex_fta_ch+=FtaParserleng; return SLACK;}
 159 WATCHLIST|Watchlist|watchlist    {flex_fta_ch+=FtaParserleng; return WATCHLIST;}
 160
 161 TRUE    { flex_fta_ch+=FtaParserleng; return TRUE_V;}
 162 FALSE   { flex_fta_ch+=FtaParserleng; return FALSE_V;}
 163 TIMEVAL { flex_fta_ch+=FtaParserleng; return TIMEVAL_L;}
 164 HEX     { flex_fta_ch+=FtaParserleng; return HEX_L;}
 165 LHEX    { flex_fta_ch+=FtaParserleng; return LHEX_L;}
 166 IP_VAL  { flex_fta_ch+=FtaParserleng; return IP_L;}
 167 IPV6_VAL|IPv6_VAL       { flex_fta_ch+=FtaParserleng; return IPV6_L;}
 168
 169 DEFINE  { flex_fta_ch+=FtaParserleng; return DEFINE_SEC;}
 170 PARAM   { flex_fta_ch+=FtaParserleng; return PARAM_SEC;}
 171
 172 [\{]    {flex_fta_ch+=FtaParserleng; return LEFTBRACE;}
 173 [\}]    {flex_fta_ch+=FtaParserleng; return RIGHTBRACE;}
 174
 175  /*
 176                 Table definition keywords
 177  */
 178 TABLE           { flex_fta_ch+=FtaParserleng; return TABLE; }
 179 PROTOCOL                { flex_fta_ch+=FtaParserleng; return PROTOCOL; }
 180 STREAM          { flex_fta_ch+=FtaParserleng; return STREAM; }
 181 FTA                     { flex_fta_ch+=FtaParserleng; return FTA; }
 182 UNPACK_FCNS                     { flex_fta_ch+=FtaParserleng; return UNPACK_FCNS; }
 183
 184 OPERATOR                        { flex_fta_ch+=FtaParserleng; return OPERATOR; }
 185 OPERATOR_VIEW                   { flex_fta_ch+=FtaParserleng; return OPERATOR_VIEW; }
 186 FIELDS                  { flex_fta_ch+=FtaParserleng; return FIELDS; }
 187 SUBQUERIES                      { flex_fta_ch+=FtaParserleng; return SUBQUERIES; }
 188 SELECTION_PUSHDOWN                      { flex_fta_ch+=FtaParserleng; return SELECTION_PUSHDOWN; }
 189 ;       {flex_fta_ch+=FtaParserleng; return SEMICOLON;}
 190
 191
 192         /* punctuation */
 193 "<<"    |
 194 ">>"                    { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return SHIFT_OP; }
 195
 196 "="     |
 197 "<>"    |
 198 "<"     |
 199 ">"     |
 200 "<="    |
 201 ">="            { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return COMPARISON; }
 202
 203 [%&|!+*/:(),.\[\]$@#]   { flex_fta_ch+=FtaParserleng; return yytext[0]; }
 204 "-"     { flex_fta_ch+=FtaParserleng; return yytext[0]; }
 205 "~"     { flex_fta_ch+=FtaParserleng; return yytext[0]; }
 206
 207         /* names */
 208
 209 [A-Za-z_][A-Za-z0-9_]*  { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return NAME; }
 210
 211         /* numbers */
 212
 213 [0-9]+  |
 214 [0-9]+UL        { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext);  return INTNUM; }
 215
 216 [0-9]+ULL       { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext);  return LONGINTNUM; }
 217
 218 [0-9]+"."[0-9]* |
 219 "."[0-9]*       |
 220 [0-9]+[eE][+-]?[0-9]+   |
 221 [0-9]+"."[0-9]*[eE][+-]?[0-9]+ |
 222 "."[0-9]*[eE][+-]?[0-9]+        { flex_fta_ch+=FtaParserleng; FtaParserlval.strval = strdup(yytext); return APPROXNUM; }
 223
 224         /* strings */
 225
 226 '[^'\n]*'       {
 227
 228                 int c;
 229
 230                 FtaParserlval.strval = strdup(FtaParsertext+1);
 231
 232                 c = yyinput();
 233
 234                 unput(c);       /* just peeking */
 235                 if(c != '\'') {
 236                         flex_fta_ch+=FtaParserleng;
 237                         FtaParserlval.strval[FtaParserleng-2] = '\0';
 238                         return STRING_TOKEN;
 239                 } else
 240                         yymore();
 241         }
 242
 243 '[^'\n]*$       { flex_fta_ch+=FtaParserleng; FtaParsererror("Unterminated string"); }
 244
 245  /*                                                                                                                     */
 246  /*             Newline : advance the error reporting line number       */
 247  /*             and grab the next line into flex_fta_linebuf                    */
 248  /*                                                                                                                     */
 249
 250 \n.*            {flex_fta_ch=0; flex_fta_lineno++;
 251                            strcpy(flex_fta_linebuf,FtaParsertext+1);
 252                            yyless(1);
 253                            }
 254
 255 [ \t\r]+        {flex_fta_ch+=FtaParserleng; }  /* white space */
 256
 257 "--".*$         {flex_fta_ch+=FtaParserleng; }; /* comment */
 258 "//".*$         {flex_fta_ch+=FtaParserleng; }; /* comment */
 259
 260 .|\n            {flex_fta_ch+=FtaParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n");  FtaParsererror(yytext);}
 261
 262 %%
 263
 264 int my_FtaParser_yyinput(char *buf, int max_size){
 265         int c = 0;
 266         int inchar = 0;
 267
 268         if(flex_fta_stringinput != NULL){
 269                 while(c<max_size){
 270                         if(flex_fta_stringinput[flex_fta_stringinput_ptr] != '\0'){
 271                                 buf[c++] = flex_fta_stringinput[flex_fta_stringinput_ptr++];
 272                         }else{
 273                                 break;
 274                         }
 275                 }
 276                 return(c);
 277         }
 278
 279         if(flex_fta_fileinput != NULL){
 280                 while(c < max_size){
 281                         inchar = getc(flex_fta_fileinput);
 282                         if(inchar != EOF){
 283                                 buf[c++] = inchar;
 284                         }else{
 285                                 break;
 286                         }
 287                 }
 288                 return(c);
 289         }
 290
 291         return(0);
 292 }
 293
 294 void FtaParser_setfileinput(FILE *f){
 295         FtaParserrestart(NULL);
 296
 297         flex_fta_fileinput = f;
 298         flex_fta_stringinput = NULL;
 299         flex_fta_lineno = 1;
 300         flex_fta_ch = 0;
 301 }
 302
 303 void FtaParser_setstringinput(char *s){
 304         FtaParserrestart(NULL);
 305
 306         flex_fta_fileinput = NULL;
 307         flex_fta_stringinput = s;
 308         flex_fta_stringinput_ptr = 0;
 309         flex_fta_lineno = 1;
 310         flex_fta_ch = 0;
 311 }
 312
 313
 314
 315