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

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