omega_interface/parser.l

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