parser.l

   1 %{
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <omega/AST.h>
   5 #include <basic/Dynamic_Array.h>
   6 #include <code_gen/mmap-codegen.h>
   7 #include "y.tab.hh"
   8 #include <omega/calc_debug.h>
   9 #ifdef WIN32
  10 #include <io.h>
  11 #define isatty _isatty
  12 #include <malloc.h>
  13 #define alloca _alloca
  14 #endif
  15
  16 extern "C" int yywrap() {return 1;};
  17
  18
  19 #if defined BRAIN_DAMAGED_FREE
  20 void free(void *p);
  21 void *realloc(void *p, size_t s);
  22 #else
  23 #define free(x)         free((char *)(x))
  24 #endif
  25
  26 char scanBuf[1024];
  27 void initializeScanBuffer() {
  28         scanBuf[0] = '\0';
  29         };
  30 int yylineno = 1;
  31 void flushScanBuffer() {
  32         fprintf(yyout,"# %s\n",scanBuf);
  33         if (omega_calc_debug) fprintf(DebugFile,"# %s\n",scanBuf);
  34         initializeScanBuffer();
  35         }
  36 #define BUFFER strcat(scanBuf,yytext)
  37 void yyerror(char *s) {
  38     fprintf(stderr,"%s\n",s);
  39     fprintf(stderr,"line %d, at end of \"%s\"\n",yylineno,scanBuf);
  40     }
  41
  42 #define MAX_INCLUDE_DEPTH 10
  43 YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
  44 int include_stack_ptr = 0;
  45
  46 void includeFile(char *s) {
  47                  if ( include_stack_ptr >= MAX_INCLUDE_DEPTH )
  48                      {
  49                      fprintf( stderr, "Includes nested too deeply" );
  50                      exit( 1 );
  51                      }
  52
  53                  include_stack[include_stack_ptr++] =
  54                      YY_CURRENT_BUFFER;
  55
  56                  FILE *f = fopen( yytext, "r" );
  57
  58                  if ( ! f ) {
  59                         include_stack_ptr--;
  60                      fprintf( stderr, "Can't open %s\n",s);
  61                         }
  62                 else {
  63                         yyin = f;
  64                          yy_switch_to_buffer(
  65                              yy_create_buffer( yyin, YY_BUF_SIZE ) );
  66                         }
  67
  68                 }
  69
  70 %}
  71
  72 %s LATEX INCLUDE
  73
  74 %%
  75
  76
  77 "<<"            {BUFFER; BEGIN(INCLUDE); }
  78 <INCLUDE>[^>\n ]+">>"   { BUFFER;
  79                           char *s = yytext;
  80                           while (*s != '>') s++;
  81                           *s = '\0';
  82                           includeFile(s);
  83                           BEGIN(INITIAL);
  84
  85                         }
  86 <INCLUDE>[ \n]  {       fprintf(stderr,"Error in include syntax\n");
  87                         fprintf(stderr,"Use <<fname>> to include the file named fname\n");
  88                         Exit(1);
  89
  90                 }
  91
  92
  93 <LATEX>"\\ "            { BUFFER; }
  94 [ \t]+        { BUFFER; }
  95 (#[^\n]*\n)     {strncat(scanBuf,yytext,yyleng-1);yylineno++;flushScanBuffer();}
  96
  97 <LATEX>"\$\$"           { BUFFER; BEGIN 0; }
  98 "\$\$"                  { BUFFER; BEGIN LATEX; }
  99 <LATEX>"\\t"            { BUFFER; }
 100 <LATEX>"\\!"            { BUFFER; }
 101 <LATEX>"\\\\"           { BUFFER; }
 102
 103 "\n"            { yylineno++; flushScanBuffer(); }
 104 "{"             { BUFFER;  return OPEN_BRACE; }
 105 <LATEX>"\\{"            { BUFFER;  return OPEN_BRACE; }
 106 "}"             { BUFFER;  return CLOSE_BRACE; }
 107 <LATEX>"\\}"            { BUFFER;  return CLOSE_BRACE; }
 108 "approximate"           { BUFFER;  return APPROX; }
 109 "union"         { BUFFER;  return UNION; }
 110 <LATEX>"\\cup"          { BUFFER;  return UNION; }
 111 "intersection"  { BUFFER;  return INTERSECTION; }
 112 <LATEX>"\\cap"          { BUFFER;  return INTERSECTION; }
 113 "symbolic"      { BUFFER;  return SYMBOLIC; }
 114 "sym"           { BUFFER;  return SYMBOLIC; }
 115 <LATEX>"\\mid"          { BUFFER;  return VERTICAL_BAR; }
 116 <LATEX>"|"              { BUFFER;  return VERTICAL_BAR; }
 117 <LATEX>"\\st"           { BUFFER;  return SUCH_THAT; }
 118 "s.t."          { BUFFER;  return SUCH_THAT; }
 119 "inverse"       { BUFFER;  return INVERSE; }
 120 "complement"    { BUFFER;  return COMPLEMENT; }
 121 <LATEX>"\\circ" { BUFFER;  return COMPOSE; }
 122 "compose"       { BUFFER;  return COMPOSE; }
 123 "difference"    { BUFFER;  return DIFFERENCE; }
 124 "diffToRel"     { BUFFER;  return DIFFERENCE_TO_RELATION; }
 125 "project away symbols"  { BUFFER;  return PROJECT_AWAY_SYMBOLS; }
 126 "project_away_symbols"  { BUFFER;  return PROJECT_AWAY_SYMBOLS; }
 127 "projectAwaySymbols"    { BUFFER;  return PROJECT_AWAY_SYMBOLS; }
 128 "project on symbols"    { BUFFER;  return PROJECT_ON_SYMBOLS; }
 129 "project_on_symbols"    { BUFFER;  return PROJECT_ON_SYMBOLS; }
 130 "projectOnSymbols"      { BUFFER;  return PROJECT_ON_SYMBOLS; }
 131 <LATEX>"\\join" { BUFFER;  return JOIN; }
 132 "\."            { BUFFER;  return JOIN; }
 133 "join"          { BUFFER;  return JOIN; }
 134 "domain"        { BUFFER;  return DOMAIN; }
 135 "time"          { BUFFER; return TIME; }
 136 "timeclosure"   { BUFFER; return TIMECLOSURE; }
 137 "range"         { BUFFER;  return RANGE; }
 138 <LATEX>"\\forall"       { BUFFER;  return FORALL; }
 139 "forall"        { BUFFER;  return FORALL; }
 140 <LATEX>"\\exists"       { BUFFER;  return EXISTS; }
 141 "exists"        { BUFFER;  return EXISTS; }
 142 "PairwiseCheck"         { BUFFER;  return PAIRWISE_CHECK; }
 143 "Venn"          { BUFFER;  return VENN; }
 144 "ConvexCheck"           { BUFFER;  return CONVEX_CHECK; }
 145 "ConvexCombination"             { BUFFER;  return CONVEX_COMBINATION; }
 146 "PositiveCombination"           { BUFFER;  return POSITIVE_COMBINATION; }
 147 "ConvexHull"            { BUFFER;  return CONVEX_HULL; }
 148 "AffineHull"            { BUFFER;  return AFFINE_HULL; }
 149 "ConicHull"             { BUFFER;  return CONIC_HULL; }
 150 "LinearHull"            { BUFFER;  return LINEAR_HULL; }
 151 "hull"          { BUFFER;  return HULL; }
 152 "minimize"              { BUFFER;  return MINIMIZE; }
 153 "maximize"              { BUFFER;  return MAXIMIZE; }
 154 "minimize-range"                { BUFFER;  return MINIMIZE_RANGE; }
 155 "maximize-range"                { BUFFER;  return MAXIMIZE_RANGE; }
 156 "minimizerange"         { BUFFER;  return MINIMIZE_RANGE; }
 157 "maximizerange"         { BUFFER;  return MAXIMIZE_RANGE; }
 158 "minimize-domain"               { BUFFER;  return MINIMIZE_DOMAIN; }
 159 "maximize-domain"               { BUFFER;  return MAXIMIZE_DOMAIN; }
 160 "minimizedomain"                { BUFFER;  return MINIMIZE_DOMAIN; }
 161 "maximizedomain"                { BUFFER;  return MAXIMIZE_DOMAIN; }
 162 "gist"          { BUFFER;  return GIST; }
 163 "given"         { BUFFER;  return GIVEN; }
 164 "within"        { BUFFER;  return WITHIN; }
 165 "subset"        { BUFFER;  return SUBSET; }
 166 "codegen"       { BUFFER;  return CODEGEN; }
 167 "tcodegen"      { BUFFER;  return TCODEGEN; }
 168 "trans_is"      { BUFFER;  return TRANS_IS; }
 169 "trans-is"      { BUFFER;  return TRANS_IS; }
 170 "set_mmap"      { BUFFER;  return SET_MMAP; }
 171 "set-mmap"      { BUFFER;  return SET_MMAP; }
 172 "unroll_is"     { BUFFER;  return UNROLL_IS; }
 173 "unroll-is"     { BUFFER;  return UNROLL_IS; }
 174 "peel_is"       { BUFFER;  return PEEL_IS; }
 175 "peel-is"       { BUFFER;  return PEEL_IS; }
 176 "spmd"          { BUFFER;  return SPMD; }
 177 "farkas"         { BUFFER;  return FARKAS; }
 178 "decoupledfarkas"         { BUFFER;  return DECOUPLED_FARKAS; }
 179 "decoupled-farkas"         { BUFFER;  return DECOUPLED_FARKAS; }
 180 "decoupled_farkas"         { BUFFER;  return DECOUPLED_FARKAS; }
 181 "upper_bound"         { BUFFER;  return MAKE_UPPER_BOUND; }
 182 "lower_bound"         { BUFFER;  return MAKE_LOWER_BOUND; }
 183 "supersetof"    { BUFFER;  return SUPERSETOF;}
 184 "subsetof"      { BUFFER;  return SUBSETOF;}
 185 "sym_example"   { BUFFER;  return SYM_SAMPLE;}
 186 "example"       { BUFFER;  return SAMPLE;}
 187 "carried_by"    { BUFFER;  return CARRIED_BY;}
 188 "iterations"    { BUFFER;  return ITERATIONS; }
 189 "reachable"     { BUFFER;  return REACHABLE_FROM; }
 190 "reachable of"     { BUFFER;  return REACHABLE_OF; }
 191 "restrict_domain"       { BUFFER;  return RESTRICT_DOMAIN; }
 192 "restrictDomain"        { BUFFER;  return RESTRICT_DOMAIN; }
 193 <LATEX>"\\"     { yyerror("Can't use \\ for restrict_domain in Tex mode"); }
 194 "\\"            { BUFFER;  return RESTRICT_DOMAIN; }
 195 "restrict_range"        { BUFFER;  return RESTRICT_RANGE; }
 196 "restrictRange"         { BUFFER;  return RESTRICT_RANGE; }
 197 "assertUnsatisfiable"   { BUFFER;  return ASSERT_UNSAT; }
 198 "assert_unsatisfiable"  { BUFFER;  return ASSERT_UNSAT; }
 199 "count"         { BUFFER;  return COUNT; }
 200 "yaml"          { BUFFER;  return YAML; }
 201 "/"             { BUFFER;  return RESTRICT_RANGE; }
 202 "&"             { BUFFER;  return AND; }
 203 "|"             { BUFFER;  return OR; }
 204 "&&"            { BUFFER;  return AND; }
 205 "||"            { BUFFER;  return OR; }
 206 "and"           { BUFFER;  return AND; }
 207 "or"            { BUFFER;  return OR; }
 208 <LATEX>"\\land" { BUFFER;  return AND; }
 209 <LATEX>"\\lor"  { BUFFER;  return OR; }
 210 "!"             { BUFFER;  return NOT; }
 211 "not"           { BUFFER;  return NOT; }
 212 <LATEX>"\\neg"  { BUFFER;  return NOT; }
 213 ":="            { BUFFER;  return IS_ASSIGNED; }
 214 "->"            { BUFFER;  return GOES_TO; }
 215 "in"            { BUFFER;  return IN; }
 216 <LATEX>"\\rightarrow"   { BUFFER;  return GOES_TO; }
 217 "<="            { BUFFER;  yylval.REL_OPERATOR = leq;
 218                   return REL_OP;
 219                   }
 220 <LATEX>"\\leq"          { BUFFER;  yylval.REL_OPERATOR = leq;
 221                   return REL_OP;
 222                   }
 223 <LATEX>"\\le"           { BUFFER;  yylval.REL_OPERATOR = leq;
 224                   return REL_OP;
 225                   }
 226 ">="            { BUFFER;  yylval.REL_OPERATOR = geq;
 227                   return REL_OP;
 228                   }
 229 <LATEX>"\\geq"          { BUFFER;  yylval.REL_OPERATOR = geq;
 230                   return REL_OP;
 231                   }
 232 <LATEX>"\\ge"           { BUFFER;  yylval.REL_OPERATOR = geq;
 233                   return REL_OP;
 234                   }
 235 "!="            { BUFFER;  yylval.REL_OPERATOR = neq;
 236                   return REL_OP;
 237                   }
 238 <LATEX>"\\neq"          { BUFFER;  yylval.REL_OPERATOR = neq;
 239                   return REL_OP;
 240                   }
 241 "<"             { BUFFER;  yylval.REL_OPERATOR = lt;
 242                   return REL_OP;
 243                   }
 244 ">"             { BUFFER;  yylval.REL_OPERATOR = gt;
 245                   return REL_OP;
 246                   }
 247 "="             { BUFFER;  yylval.REL_OPERATOR = eq;
 248                   return REL_OP;
 249                   }
 250 [A-Za-z][A-Za-z0-9_']*  { BUFFER;  if (yyleng > 19) yyerror("Identifier too long");
 251                           yylval.VAR_NAME = (char *) malloc(1+yyleng);
 252                           strcpy(yylval.VAR_NAME,yytext);
 253                           return VAR;
 254                           }
 255 [A-Za-z][A-Za-z0-9_]*"(in)" { BUFFER; if (yyleng > 19) yyerror("Identifier too long");
 256                           yylval.VAR_NAME = (char *) malloc(1+yyleng);
 257                           strcpy(yylval.VAR_NAME,yytext);
 258                           yylval.VAR_NAME[yyleng-3] = 'i';  // lowercase
 259                           yylval.VAR_NAME[yyleng-2] = 'n';
 260                           return VAR;
 261                           }
 262 [A-Za-z][A-Za-z0-9_]*"(set)" { BUFFER; if (yyleng > 19) yyerror("Identifier too long");
 263                           yylval.VAR_NAME = (char *) malloc(1+yyleng);
 264                           strcpy(yylval.VAR_NAME,yytext);
 265                           yylval.VAR_NAME[yyleng-4] = 'i';  // Change to "in"
 266                           yylval.VAR_NAME[yyleng-3] = 'n';  // Be afraid
 267                           yylval.VAR_NAME[yyleng-2] = ')';
 268                           yylval.VAR_NAME[yyleng-1] = '\0';
 269                           return VAR;
 270                           }
 271 [A-Za-z][A-Za-z0-9_]*"(out)" { BUFFER; if (yyleng > 19) yyerror("Identifier too long");
 272                           yylval.VAR_NAME = (char *) malloc(1+yyleng);
 273                           strcpy(yylval.VAR_NAME,yytext);
 274                           yylval.VAR_NAME[yyleng-4] = 'o';  // lowercase
 275                           yylval.VAR_NAME[yyleng-3] = 'u';
 276                           yylval.VAR_NAME[yyleng-2] = 't';
 277                           return VAR;
 278                           }
 279
 280 <LATEX>"\\"[A-Za-z][A-Za-z0-9_]*        { BUFFER;
 281                           if (yyleng > 19) yyerror("Identifier too long");
 282                           yylval.VAR_NAME = (char *) malloc(1+yyleng);
 283                           strcpy(yylval.VAR_NAME,yytext);
 284                           return VAR;
 285                           }
 286 <LATEX>"\\"[A-Za-z][A-Za-z0-9_]*"(in)" { BUFFER; if (yyleng > 19) yyerror("Identifier too long");
 287                           yylval.VAR_NAME = (char *) malloc(1+yyleng);
 288                           strcpy(yylval.VAR_NAME,yytext);
 289                           yylval.VAR_NAME[yyleng-3] = 'i';  // lowercase
 290                           yylval.VAR_NAME[yyleng-2] = 'n';
 291                           return VAR;
 292                           }
 293 <LATEX>"\\"[A-Za-z][A-Za-z0-9_]*"(set)" { BUFFER; if (yyleng > 19) yyerror("Identifier too long");
 294                           yylval.VAR_NAME = (char *) malloc(1+yyleng);
 295                           strcpy(yylval.VAR_NAME,yytext);
 296                           yylval.VAR_NAME[yyleng-4] = 'i';  // Change to "in"
 297                           yylval.VAR_NAME[yyleng-3] = 'n';  // Be afraid
 298                           yylval.VAR_NAME[yyleng-2] = ')';
 299                           yylval.VAR_NAME[yyleng-1] = '\0';
 300                           return VAR;
 301                           }
 302 <LATEX>"\\"[A-Za-z][A-Za-z0-9_]*"(out)" { BUFFER; if (yyleng > 19) yyerror("Identifier too long");
 303                           yylval.VAR_NAME = (char *) malloc(1+yyleng);
 304                           strcpy(yylval.VAR_NAME,yytext);
 305                           yylval.VAR_NAME[yyleng-4] = 'o';  // lowercase
 306                           yylval.VAR_NAME[yyleng-3] = 'u';
 307                           yylval.VAR_NAME[yyleng-2] = 't';
 308                           return VAR;
 309                           }
 310 [0-9]+          { BUFFER;  yylval.INT_VALUE = atoi(yytext);
 311                   return INT;
 312                         }
 313 \"[^"]*\"       { BUFFER;
 314                   yytext[strlen(yytext)-1]='\0';
 315                   yylval.STRING_VALUE = new String(yytext+1);
 316                   return STRING;
 317                 }
 318 <<EOF>> {
 319                  if ( --include_stack_ptr < 0 )
 320                      {
 321                      yyterminate();
 322                      }
 323                 else
 324                      {
 325                      yy_delete_buffer( YY_CURRENT_BUFFER );
 326                      yy_switch_to_buffer(
 327                           include_stack[include_stack_ptr] );
 328                      }
 329                  }
 330
 331 .               { BUFFER;  return yytext[0]; }
 332