Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/src/MLRISC/Tools/Parser/mdl.lex
ViewVC logotype

Annotation of /sml/trunk/src/MLRISC/Tools/Parser/mdl.lex

Parent Directory Parent Directory | Revision Log Revision Log


Revision 935 - (view) (download)

1 : leunga 744 exception Error
2 :    
3 :     type pos = int
4 :     type svalue = Tokens.svalue
5 :     type ('a,'b) token = ('a,'b) Tokens.token
6 :     type lexresult = (svalue,pos) token
7 : george 935 type lexarg = {srcMap : SourceMapping.sourcemap,
8 : leunga 744 err : pos * pos * string -> unit,
9 :     MDLmode : bool
10 :     }
11 :     type arg = lexarg
12 :    
13 :     open Tokens
14 :    
15 :     val commentLevel = ref 0
16 :     val metaLevel = ref 0
17 :    
18 :     val asmLQuote = ref "``"
19 :     val asmRQuote = ref "''"
20 :     val asmLMeta = ref "<"
21 :     val asmRMeta = ref ">"
22 :    
23 :     exception Error
24 :    
25 :     fun init() = (commentLevel := 0; metaLevel := 0;
26 :     asmLQuote := "``"; asmRQuote := "''";
27 :     asmLMeta := "<"; asmRMeta := ">"
28 :     )
29 :    
30 :     fun eof{srcMap,err,MDLmode} =
31 : george 935 let val pos = SourceMapping.currPos srcMap
32 : leunga 744 in EOF(pos,pos) end
33 :     fun debug _ = ()
34 :    
35 :     fun check(err,_,_,SOME w) = w
36 :     | check(err,pos,s,NONE) =
37 :     (err(pos,pos+size s,"bad literal "^s); raise Error)
38 :    
39 :     fun strip k s = String.substring(s,k,String.size s - k)
40 :     fun scan err fmt (s,s') tok pos =
41 :     tok(check(err,pos,s,StringCvt.scanString fmt s'),
42 :     pos,pos + size s)
43 :     handle _ => ID(s,pos,pos)
44 :    
45 :     fun wdecimal(err,s,pos) =
46 :     scan err (Word32.scan StringCvt.DEC) (s,strip 2 s) WORD pos
47 :     fun whex(err,s,pos) =
48 :     scan err (Word32.scan StringCvt.HEX) (s,strip 3 s) WORD pos
49 :     fun woctal(err,s,pos) = scan err (Word32.scan StringCvt.OCT) (s,strip 3 s) WORD pos
50 :     fun wbinary(err,s,pos) = scan err (Word32.scan StringCvt.BIN) (s,strip 3 s) WORD pos
51 :     fun decimal(err,s,pos) = scan err (Int.scan StringCvt.DEC) (s,s) INT pos
52 : leunga 775 fun real(err,s,pos) = scan err (Real.scan) (s,s)
53 :     (fn (x,y,z) => REAL(Real.toString x, y, z)) pos
54 : leunga 744 fun hex(err,s,pos) = scan err (Int.scan StringCvt.HEX) (s,strip 2 s) INT pos
55 :     fun octal(err,s,pos) = scan err (Int.scan StringCvt.OCT) (s,strip 2 s) INT pos
56 :     fun binary(err,s,pos) = scan err (Int.scan StringCvt.BIN) (s,strip 2 s) INT pos
57 :    
58 : leunga 775 fun decimalinf(err,s,pos) = scan err (IntInf.scan StringCvt.DEC) (s,s) INTINF pos
59 :     fun hexinf(err,s,pos) = scan err (IntInf.scan StringCvt.HEX) (s,strip 2 s) INTINF pos
60 :     fun octalinf(err,s,pos) = scan err (IntInf.scan StringCvt.OCT) (s,strip 2 s) INTINF pos
61 :     fun binaryinf(err,s,pos) = scan err (IntInf.scan StringCvt.BIN) (s,strip 2 s) INTINF pos
62 :    
63 : leunga 744 fun string(err,s,pos) =
64 :     STRING(
65 :     check(err,pos,s,String.fromString(String.substring(s,1,String.size s-2))),
66 :     pos, pos + size s)
67 :     fun char(err,s,pos) =
68 :     CHAR(check(err,pos,s,Char.fromString(String.substring(s,2,String.size s-3))),
69 :     pos,pos + size s)
70 : george 782 fun transAsm s =
71 :     let fun loop(#"\\" :: #"<" ::s) = #"<"::loop s
72 :     | loop(#"\\" :: #">" ::s) = #">"::loop s
73 :     | loop(c::s) = c::loop s
74 :     | loop [] = []
75 :     in String.implode(loop(String.explode s))
76 :     end
77 :    
78 : leunga 744 fun asmtext(err,s,pos) =
79 : george 782 ASMTEXT(check(err,pos,s,String.fromString(transAsm s)),pos,pos + size s)
80 : leunga 744
81 :     infix $$
82 :     fun x $$ y = y :: x
83 :    
84 :     exception NotFound
85 :    
86 :     val keywords = HashTable.mkTable (HashString.hashString,op =) (13,NotFound)
87 :     : (string,int * int -> (svalue,int) token) HashTable.hash_table
88 :     val MDLkeywords = HashTable.mkTable (HashString.hashString,op =) (13,NotFound)
89 :     : (string,int * int -> (svalue,int) token) HashTable.hash_table
90 :     val symbols = HashTable.mkTable (HashString.hashString,op =) (13,NotFound)
91 :     : (string,int * int -> (svalue,int) token) HashTable.hash_table
92 :    
93 :     val _ = app (HashTable.insert keywords)
94 :     ( nil $$
95 :     ("_",WILD) $$
96 :     ("datatype", DATATYPE) $$
97 :     ("type", TYPE) $$
98 :     ("end", END) $$
99 :     ("fun", FUN) $$
100 :     ("fn", FN) $$
101 :     ("val", VAL) $$
102 :     ("raise", RAISE) $$
103 :     ("handle", HANDLE) $$
104 :     ("let", LET) $$
105 :     ("local", LOCAL) $$
106 : leunga 775 ("exception", EXCEPTION) $$
107 : leunga 744 ("structure", STRUCTURE) $$
108 :     ("signature", SIGNATURE) $$
109 :     ("functor", FUNCTOR) $$
110 :     ("sig", SIG) $$
111 :     ("struct", STRUCT) $$
112 :     ("sharing", SHARING) $$
113 :     ("where", WHERE) $$
114 :     ("withtype", WITHTYPE) $$
115 :     ("if", IF) $$
116 :     ("then", THEN) $$
117 :     ("else", ELSE) $$
118 :     ("in", IN) $$
119 :     ("true", TRUE) $$
120 :     ("false", FALSE) $$
121 :     ("and", AND) $$
122 :     ("at", AT) $$
123 :     ("of", OF) $$
124 :     ("case", CASE) $$
125 :     ("as", AS) $$
126 :     ("open", OPEN) $$
127 : leunga 775 ("op", OP) $$
128 : leunga 744 ("include", INCLUDE) $$
129 :     ("infix", INFIX) $$
130 :     ("infixr", INFIXR) $$
131 :     ("nonfix", NONFIX) $$
132 :     ("not", NOT)
133 :     )
134 :    
135 :     val _ = app (HashTable.insert MDLkeywords)
136 :     ( nil $$
137 :     ("architecture", ARCHITECTURE) $$
138 :     ("assembly", ASSEMBLY) $$
139 :     ("storage", STORAGE) $$
140 :     ("locations", LOCATIONS) $$
141 :     ("equation", EQUATION) $$
142 :     ("at", AT) $$
143 :     ("vliw", VLIW) $$
144 :     ("field", FIELD) $$
145 :     ("fields", FIELDS) $$
146 :     ("signed", SIGNED) $$
147 :     ("unsigned", UNSIGNED) $$
148 :     ("superscalar", SUPERSCALAR) $$
149 :     ("bits", BITS) $$
150 :     ("ordering", ORDERING) $$
151 :     ("little", LITTLE) $$
152 :     ("big", BIG) $$
153 :     ("endian", ENDIAN) $$
154 :     ("register", REGISTER) $$
155 :     ("as", AS) $$
156 :     ("cell", CELL) $$
157 :     ("cells", CELLS) $$
158 :     ("cellset", CELLSET) $$
159 :     ("pipeline", PIPELINE) $$
160 :     ("cpu", CPU) $$
161 :     ("resource", RESOURCE) $$
162 :     ("reservation", RESERVATION) $$
163 :     ("table", TABLE) $$
164 :     ("latency", LATENCY) $$
165 :     ("predicated", PREDICATED) $$
166 :     ("instruction", INSTRUCTION) $$
167 :     ("formats", FORMATS) $$
168 :     ("uppercase", UPPERCASE) $$
169 :     ("lowercase", LOWERCASE) $$
170 :     ("verbatim", VERBATIM) $$
171 :     ("span", SPAN) $$
172 :     ("dependent", DEPENDENT) $$
173 :     ("always", ALWAYS) $$
174 :     ("never", NEVER) $$
175 :     ("delayslot", DELAYSLOT) $$
176 :     (* ("branching", BRANCHING) $$ *)
177 :     ("candidate", CANDIDATE) $$
178 :     ("rtl", RTL) $$
179 :     ("debug", DEBUG) $$
180 :     ("aliasing", ALIASING) $$
181 :     ("aggregable",AGGREGABLE)
182 :     )
183 :    
184 :     val _ = app (HashTable.insert symbols)
185 :     (
186 :     nil $$
187 :     ("=", EQ) $$
188 :     ("*", TIMES) $$
189 :     (":", COLON) $$
190 :     ("|", BAR) $$
191 :     ("->", ARROW) $$
192 :     ("=>", DARROW) $$
193 :     ("#", HASH) $$
194 :     ("!", DEREF) $$
195 :     ("^^", CONCAT)
196 :     )
197 :    
198 :     fun lookup(MDLmode,s,yypos) =
199 :     let val l = String.size s
200 : george 935 fun id() = ID(UniqueSymbol.toString
201 :     (UniqueSymbol.fromString s), yypos, yypos + l)
202 : leunga 744 in HashTable.lookup keywords s (yypos,yypos + l)
203 :     handle _ =>
204 :     (if MDLmode then
205 :     (HashTable.lookup MDLkeywords s (yypos,yypos + l) handle _ => id())
206 :     else id()
207 :     )
208 :     end
209 :    
210 :     fun lookupSym(s,yypos) =
211 :     let val l = String.size s
212 :     in HashTable.lookup symbols s (yypos,yypos + l)
213 : george 935 handle _ => SYMBOL(UniqueSymbol.toString
214 :     (UniqueSymbol.fromString s), yypos, yypos + l)
215 : leunga 744 end
216 :    
217 :     %%
218 :    
219 :     %header (functor MDLLexFun(Tokens : MDL_TOKENS));
220 :     %arg ({srcMap,err,MDLmode});
221 :    
222 :     alpha=[A-Za-z];
223 :     digit=[0-9];
224 :     id=[A-Za-z_][A-Za-z0-9_\']*;
225 :     tyvar=\'{id};
226 :     decimal={digit}+;
227 : leunga 775 integer=~?{decimal};
228 :     real={integer}\.{decimal}(e{integer})?;
229 : leunga 744 octal=0[0-7]+;
230 :     hex=0x[0-9a-fA-F]+;
231 :     binary=0b[0-1]+;
232 :     wdecimal=0w{digit}+;
233 :     woctal=0w0[0-7]+;
234 :     whex=0wx[0-9a-fA-F]+;
235 :     wbinary=0wb[0-1]+;
236 :     ws=[\ \t];
237 :     string=\"([^\\\n\t"]|\\.)*\";
238 :     char=#\"([^\\\n\t"]|\\.)*\";
239 :     sym1=(\-|[=\.+~/*:!@#$%^&*|?])+;
240 :     sym2=`+|'+|\<+|\>+|\=\>|~\>\>;
241 : george 782 sym3=\\.;
242 :     asmsymbol={sym1}|{sym2}|{sym3};
243 : leunga 775 symbol=(\-|[=+~/*:!@#$%^&*|?<>])+|``|'';
244 : leunga 744 asmtext=([^\n\t<>']+|');
245 : leunga 775 inf=i;
246 : leunga 744
247 :     %s COMMENT ASM ASMQUOTE;
248 :    
249 :     %%
250 : george 935 <INITIAL,COMMENT,ASM>\n => (SourceMapping.newline srcMap yypos; continue());
251 : leunga 744 <INITIAL,COMMENT,ASM>{ws} => (continue());
252 :     <ASMQUOTE>\n => (err(yypos,yypos+size yytext,
253 :     "newline in assembly text!"); continue());
254 :     <INITIAL>\-\-.*\n => (continue());
255 :     <INITIAL>"(*" => (commentLevel := 1; YYBEGIN COMMENT; continue());
256 : leunga 775 <INITIAL,ASM>{integer} => (decimal(err,yytext,yypos));
257 : leunga 744 <INITIAL,ASM>{hex} => (hex(err,yytext,yypos));
258 :     <INITIAL,ASM>{octal} => (octal(err,yytext,yypos));
259 :     <INITIAL,ASM>{binary} => (binary(err,yytext,yypos));
260 : leunga 775 <INITIAL,ASM>{integer}{inf} => (decimalinf(err,yytext,yypos));
261 :     <INITIAL,ASM>{hex}{inf} => (hexinf(err,yytext,yypos));
262 :     <INITIAL,ASM>{octal}{inf} => (octalinf(err,yytext,yypos));
263 :     <INITIAL,ASM>{binary}{inf} => (binaryinf(err,yytext,yypos));
264 : leunga 744 <INITIAL,ASM>{wdecimal} => (wdecimal(err,yytext,yypos));
265 :     <INITIAL,ASM>{whex} => (whex(err,yytext,yypos));
266 :     <INITIAL,ASM>{woctal} => (woctal(err,yytext,yypos));
267 :     <INITIAL,ASM>{wbinary} => (wbinary(err,yytext,yypos));
268 :     <INITIAL,ASM>{string} => (string(err,yytext,yypos));
269 :     <INITIAL,ASM>{char} => (char(err,yytext,yypos));
270 : leunga 775 <INITIAL,ASM>{real} => (real(err,yytext,yypos));
271 : leunga 744 <INITIAL,ASM>"$" => (if MDLmode then DOLLAR(yypos,yypos+1)
272 :     else SYMBOL("$",yypos,yypos+1));
273 :     <INITIAL,ASM>"asm:" => (ASM_COLON(yypos,yypos + size yytext));
274 :     <INITIAL,ASM>"mc:" => (MC_COLON(yypos,yypos + size yytext));
275 :     <INITIAL,ASM>"rtl:" => (RTL_COLON(yypos,yypos + size yytext));
276 :     <INITIAL,ASM>"delayslot:" => (DELAYSLOT_COLON(yypos,size yytext));
277 :     <INITIAL,ASM>"padding:" => (PADDING_COLON(yypos,size yytext));
278 :     <INITIAL,ASM>"nullified:" => (NULLIFIED_COLON(yypos,size yytext));
279 :     <INITIAL,ASM>"candidate:" => (CANDIDATE_COLON(yypos,size yytext));
280 :     <INITIAL,ASM>{id} => (lookup(MDLmode,yytext,yypos));
281 :     <INITIAL,ASM>{tyvar} => (TYVAR(yytext,yypos,yypos + size yytext));
282 :     <INITIAL,ASM>"(" => (LPAREN(yypos,yypos+1));
283 :     <INITIAL,ASM>")" => (RPAREN(yypos,yypos+1));
284 :     <INITIAL,ASM>"[" => (LBRACKET(yypos,yypos+1));
285 :     <INITIAL,ASM>"]" => (RBRACKET(yypos,yypos+1));
286 :     <INITIAL,ASM>"{" => (LBRACE(yypos,yypos+1));
287 :     <INITIAL,ASM>"}" => (RBRACE(yypos,yypos+1));
288 :     <INITIAL,ASM>"," => (COMMA(yypos,yypos+1));
289 :     <INITIAL,ASM>";" => (SEMICOLON(yypos,yypos+1));
290 : leunga 775 <INITIAL,ASM>"." => (DOT(yypos,yypos+1));
291 :     <INITIAL,ASM>".." => (DOTDOT(yypos,yypos+2));
292 :     <INITIAL,ASM>"..." => (DOTDOT(yypos,yypos+3));
293 : leunga 744 <INITIAL>{symbol} => (if yytext = !asmLQuote then
294 :     (debug("lquote "^yytext^"\n");
295 :     YYBEGIN ASMQUOTE;
296 :     LDQUOTE(yypos,yypos+size yytext))
297 :     else
298 :     lookupSym(yytext,yypos));
299 :     <ASMQUOTE>{asmsymbol} => (if yytext = !asmRQuote then
300 :     (if !metaLevel <> 0 then
301 :     err(yypos,yypos+size yytext,
302 :     "Mismatch between "^(!asmLMeta)^
303 :     " and "^(!asmRMeta)) else ();
304 :     debug("rquote "^yytext^"\n");
305 :     YYBEGIN INITIAL;
306 :     RDQUOTE(yypos,yypos+size yytext))
307 :     else if yytext = !asmLMeta then
308 :     (metaLevel := !metaLevel + 1;
309 :     debug("lmeta "^yytext^"\n");
310 :     YYBEGIN ASM; LMETA(yypos,yypos+size yytext))
311 :     else
312 :     asmtext(err,yytext,yypos));
313 :     <ASM>{asmsymbol} => (if yytext = !asmRMeta then
314 :     (metaLevel := !metaLevel - 1;
315 :     debug("rmeta "^yytext^"("^Int.toString(!metaLevel)^")\n");
316 :     if !metaLevel = 0 then YYBEGIN ASMQUOTE
317 :     else (); RMETA(yypos,yypos+size yytext))
318 :     else
319 :     lookupSym(yytext,yypos));
320 :     <ASMQUOTE>{asmtext} => (debug("text="^yytext^"\n");
321 :     asmtext(err,yytext,yypos));
322 :     <COMMENT>"*)" => (commentLevel := !commentLevel - 1;
323 :     if !commentLevel = 0 then YYBEGIN INITIAL else ();
324 :     continue());
325 :     <COMMENT>"(*" => (commentLevel := !commentLevel + 1; continue());
326 :     <COMMENT>. => (continue());
327 :     . => (err(yypos,yypos+size yytext,
328 :     "unknown character "^String.toString yytext);
329 :     continue());

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0