src/apc/lexer_fsm.rl

   1 #include <stdio.h>
   2 #include <stdint.h>
   3 #include <apc/parser.tab.h>
   4 #include <unistdio.h>
   5
   6 extern void lexer_pushtok(int, YYSTYPE);
   7 extern int lexer_lexmapfile(int, int);
   8 extern int lexer_lexelemodel(uint8_t*);
   9 extern int lexer_lexsetmodel(uint8_t*);
  10 extern int lexer_lexsetmap(uint8_t*);
  11 extern int lexer_lexelemap(uint8_t*);
  12 extern int lexer_lexsetvlink(uint8_t*);
  13 extern int lexer_lexelevlink(uint8_t*);
  14 extern int lexer_lexsetolink(uint8_t*);
  15 extern int lexer_lexeleolink(uint8_t*);
  16 extern int ipower(int, int);
  17 extern int ttov(uint8_t*, int);
  18 extern uint8_t* ttos(const uint8_t*, int);
  19
  20 int lexer_lexstring(uint8_t*, int);
  21 int lexer_setstr(uint8_t*, int);
  22
  23 #define $($)#$
  24 #define PUSHTOK(TOK,LFUNC,UTYPE)                        \
  25   do {                                                  \
  26     printf("PUSHTOK(" $(TOK) $(LFUNC) $(UTYPE) ")\n");          \
  27     tok_t = TOK;                                        \
  28     yylval.UTYPE = LFUNC(ts, p-ts);                     \
  29     lexer_pushtok(tok_t, yylval);                       \
  30     ++ntok;                                             \
  31     } while (0);
  32
  33 %%{
  34   machine setstr;
  35
  36
  37   action lex_setvlink {printf("Returning setvlink filetype for %s\n", str); type =  5; newstrt = lexer_lexsetvlink(str); fbreak;}
  38   action lex_elevlink {printf("Returning elevlink filetype for %s\n", str); type =  6; newstrt = lexer_lexelevlink(str); fbreak;}
  39   action lex_setmodel {printf("Returning setmodel filetype\n"); newstrt = lexer_lexsetmodel(str); type =  1; fbreak;}
  40   action lex_setmap {printf("Returning setmap filetype\n"); newstrt = lexer_lexsetmap(str); type =  2; fbreak;}
  41   action lex_elemodel {printf("Returning elemodel filetype for %s\n", str); newstrt = lexer_lexelemodel(str); type =  3; fbreak;}
  42   action lex_elemap {printf("Returning elemap filetype for %s\n", str); newstrt = lexer_lexelemap(str); type = 4; fbreak;}
  43   action lex_setolink  { printf("Returning setolink filetype\n"); type = 8; newstrt = lexer_lexsetolink(str); fbreak;}
  44   action lex_eleolink  { printf("Returning eleolink filetype\n"); type = 7; newstrt = lexer_lexeleolink(str); fbreak;}
  45   action p {printf("p = %s \n",p);}
  46
  47
  48   SSN = 'SSN';
  49   SSW = 'SSW';
  50   SSS = 'SSS';
  51   SSE = 'SSE';
  52   SSNW = 'SSNW';
  53   SSNE = 'SSNE';
  54   SSSW = 'SSSW';
  55   SSSE = 'SSSE';
  56   direction = (SSN | SSW | SSS | SSE | SSNW | SSNE | SSSW | SSSE);
  57
  58   nm = alpha >p;
  59   name = alpha+;
  60   num = digit+;
  61   refs = digit >p;
  62   ref = refs+;
  63
  64
  65   set_label = name | (name '_' ref);
  66   ele_label = (name | name '_' ref);
  67
  68   set_model =  set_label  '_'  (name  | name '_' num '_' num ) [\0]  %to(lex_setmodel) ;
  69   set_map = set_label '_' '~' '_' (name | name '_' num '_' num ) [\0] %to(lex_setmap) >p;
  70   ele_model = set_label '_' ele_label '_' direction '_' (name | name  '_' num '_' num) [\0] %to(lex_elemodel);
  71   ele_map = set_label '_' ele_label '_' '~' '_' (name | name '_' num '_' num) [\0]   %to(lex_elemap);
  72   set_olink = ref %to(lex_setolink) [\0] ;
  73   ele_olink = set_label '_' '~' '_' ref [\0] %to(lex_eleolink);
  74   set_vlink = set_label '_' '#' '_' (ref | ref '_' name) [\0]  %to(lex_setvlink);
  75   ele_vlink = set_label '_' ele_label '_' '#' '_' (ref | ref '_' name) [\0] >p %to(lex_elevlink);
  76
  77   #main := (set_model | set_map | ele_model | ele_map | set_link | ele_link);
  78
  79   #main := (set_olink | set_vlink | set_model | set_map | ele_map | ele_model | ele_olink | ele_vlink);
  80  main := name;
  81
  82
  83
  84
  85   write data;
  86
  87
  88 }%%
  89
  90 int
  91 lexer_setstr
  92 (uint8_t* str, int size)
  93 { uint8_t *p, *pe, *eof;
  94   int cs, type, newstrt;
  95
  96   type = newstrt = 0;
  97
  98   p = str;
  99   pe = str + size ;
 100
 101   printf("Starting fsm filetype with str = %s, p = %s, pe = %s\n", str,p,  pe);
 102
 103   %%write init;
 104   %%write exec noend;
 105
 106   printf("lexer_setstr is incrementing str by %d, type is %d\n", newstrt, type);
 107
 108   return newstrt;
 109 }
 110
 111 %%{
 112   machine lexstring;
 113
 114   # set up yylval and tok_t to be pushed to stack
 115   action push_ref   { PUSHTOK(REF, ttov, ref); }
 116   action push_val   { PUSHTOK(NUM, ttov, val); }
 117   action push_name  { printf("pushing NAME token from %s to %s\n", ts, p); PUSHTOK(NAME, ttos, str); }
 118   action push_map   { printf("Pushing map file\n"); yylval.str = (uint8_t*) '~'; lexer_pushtok(MOPEN, yylval); ntok++; }
 119   action set_ts    { printf("Lexstring: Setting ts (%s) = p(%s)\n", ts, p); ts = p; }
 120   action lex_error { printf("input error: character %c in filename %s is invalid\n p = %s\n", fc, str, p);}
 121
 122   # Parses a regular filename (not a mapping) and pushes
 123   # tokens to the parser
 124
 125   ref = '0x'. alnum+ %push_ref;
 126   val = digit+  %push_val;
 127   name = alpha+  %push_name ;
 128   map = '~' %push_map;
 129   tok = (ref | val | name | map);
 130   segment = tok . [_\0] %set_ts;
 131   segment_end = tok;
 132
 133   tok_lexer := segment+ [\0];
 134
 135   write data;
 136
 137 }%%
 138
 139 int
 140 lexer_lexstring
 141 (uint8_t* str, int size)
 142 { uint8_t *p;
 143   uint8_t *ts, *pe, *eof;
 144   int cs, ntok, tok_t;
 145
 146   ntok = 0;
 147   p = ts = str;
 148   pe = p + size + 1;
 149
 150   printf("Starting lexstring on str %s.\n",str);
 151
 152   %%write init;
 153   %%write exec;
 154
 155   printf("Ending lexstring of file %s, pushed %d tokens.\n",str, ntok);
 156
 157   return ntok;
 158 }
 159
 160
 161 /**************************/
 162 /****Abandon All Hope******/
 163 /**************************/
 164 /***                    ***/
 165 /***                    ***/
 166 /***                    ***/
 167 /***                    ***/
 168
 169
 170 /* %%{ */
 171 /*   machine file_matcher; */
 172
 173 /*   action call_ml { ts = p; fgoto set_hw ;} */
 174 /*   action call_tl { return 0;} */
 175 /*   action set_height {height = ttov(p, p-ts+1); ts = p;} */
 176 /*   action set_width { width = ttov(p, p-ts+1);} */
 177 /*   action call_lmf {lexer_lexmapfile(height, width); } */
 178 /*   action lex_error {printf("input error: character %c in filename %s is invalid\n  = %s\n", fc, str, p);} */
 179
 180 /*   #This machine determines the type of file we are lexing */
 181 /*   #and calls the appropriate machine to handle it. */
 182
 183 /*   #TODO add mapping name */
 184 /*   width = digit+ %set_width; */
 185 /*   height = digit+ %set_height; */
 186
 187 /*   set_hw :=  height . '_' . width [\0] %to(call_lmf); */
 188
 189 /*   tok_segment = alnum; */
 190 /*   map_end = 'm' . '_' %to(call_ml); */
 191 /*   tok_end = alnum+  . [\0] %to(call_tl); */
 192
 193 /*   file_matcher := (tok_segment+ . '_' )+ ( map_end | tok_end ); */
 194
 195 /*   write data; */
 196 /* }%% */
 197
 198 /* int */
 199 /* lexer_matchfile */
 200 /* (char* str, int size) */
 201 /* {  *p, *pe; */
 202 /*   char* ts; */
 203 /*   int  cs, ntok, height, width; */
 204
 205 /*   p =  str; */
 206 /*   pe = p + size; */
 207 /*   height = width = 0; */
 208
 209 /*   printf("Checking if filename is a map file:: filename = %s, p = %c, pe = %c\n", str, *p, *pe); */
 210
 211 /*   %%write init; */
 212 /*   %%write exec noend; */
 213
 214 /*   printf("Ending lexer_ismapfile on %s\n", str); */
 215
 216 /*   return ntok; */
 217 /* } */
 218
 219 /* %%{ */
 220 /*   machine vartype; */
 221
 222 /*   action isele {return 0;} */
 223 /*   action ismodel {return 1;} */
 224
 225 /*   set_name = alpha+; */
 226 /*   ele_name = alpha+; */
 227 /*   model_name = alpha+; */
 228
 229 /*   ele = set_name  '_' model_name '_' ele_name %isele; */
 230 /*   model = set_name '_'  model_name [\0] %ismodel; */
 231
 232
 233 /*   ismodel := (ele | model); */
 234
 235 /*   write data; */
 236
 237 /* }%% */
 238
 239 /* int */
 240 /* lexer_ismodel */
 241 /* (uint8_t* str, int size) */
 242 /* { uint8_t *p, *pe, *eof; */
 243 /*   int cs; */
 244
 245 /*   p = str; */
 246 /*   pe = p + size + 1; */
 247
 248 /*   %%write init; */
 249 /*   %%write exec; */
 250
 251
 252 /* } */