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/branches/rt-transition/cm/parse/cm.lex
ViewVC logotype

Annotation of /sml/branches/rt-transition/cm/parse/cm.lex

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2837 - (view) (download)

1 : blume 1011 (* -*- sml-lex -*-
2 : blume 267 *
3 : blume 1011 * cm.lex
4 :     *
5 : blume 267 * lexical analysis (ML-Lex specification) for CM description files
6 :     *
7 :     * (C) 1999 Lucent Technologies, Bell Laboratories
8 :     *
9 :     * Author: Matthias Blume (blume@kurims.kyoto-u.ac.jp)
10 :     *)
11 : blume 262
12 : blume 632 structure S = CMSemant
13 :    
14 : blume 262 type svalue = Tokens.svalue
15 :     type pos = int
16 : blume 265
17 : blume 262 type ('a, 'b) token = ('a, 'b) Tokens.token
18 :     type lexresult = (svalue, pos) token
19 :    
20 : blume 265 type lexarg = {
21 :     enterC: unit -> unit,
22 :     leaveC: unit -> bool,
23 : blume 294 newS: pos -> unit,
24 : blume 265 addS: char -> unit,
25 :     addSC: string * int -> unit,
26 :     addSN: string * pos -> unit,
27 : blume 266 getS: pos * (string * pos * pos -> lexresult) -> lexresult,
28 : blume 268 handleEof: unit -> pos,
29 : blume 265 newline: pos -> unit,
30 : blume 397 obsolete: pos * pos -> unit,
31 : blume 313 error: pos * pos -> string -> unit,
32 : mblume 1644 sync: pos * string -> unit,
33 :     in_section2: bool ref
34 : blume 265 }
35 : blume 262
36 : blume 265 type arg = lexarg
37 :    
38 : blume 268 fun eof (arg: lexarg) = let
39 :     val pos = #handleEof arg ()
40 : blume 262 in
41 : blume 268 Tokens.EOF (pos, pos)
42 : blume 262 end
43 :    
44 : blume 274 fun errorTok (t, p) = let
45 :     fun findGraph i =
46 :     if Char.isGraph (String.sub (t, i)) then i
47 :     else findGraph (i + 1)
48 :     fun findError i =
49 :     if String.sub (t, i) = #"e" then i
50 :     else findError (i + 1)
51 :     val start = findGraph (5 + findError 0)
52 :     val msg = String.extract (t, start, NONE)
53 : blume 262 in
54 : blume 275 Tokens.ERROR (msg, p + 1, p + size t)
55 : blume 262 end
56 :    
57 : mblume 1644 fun plain t (_: bool ref, arg) = t arg : lexresult
58 :     fun is_token (r, arg) = (r := true; Tokens.IS arg) : lexresult
59 : blume 274
60 : mblume 1644 val cm_ids = [("Group", plain Tokens.GROUP),
61 :     ("GROUP", plain Tokens.GROUP),
62 :     ("group", plain Tokens.GROUP),
63 :     ("Library", plain Tokens.LIBRARY),
64 :     ("LIBRARY", plain Tokens.LIBRARY),
65 :     ("library", plain Tokens.LIBRARY),
66 :     ("IS", is_token),
67 :     ("is", is_token),
68 :     ("*", plain Tokens.STAR),
69 :     ("-", plain Tokens.DASH),
70 :     ("Source", plain Tokens.SOURCE),
71 :     ("SOURCE", plain Tokens.SOURCE),
72 :     ("source", plain Tokens.SOURCE)]
73 :    
74 : blume 274 val ml_ids = [("structure", Tokens.STRUCTURE),
75 :     ("signature", Tokens.SIGNATURE),
76 :     ("functor", Tokens.FUNCTOR),
77 :     ("funsig", Tokens.FUNSIG)]
78 :    
79 : mblume 1644 val pp_ids = [("defined", plain Tokens.DEFINED),
80 :     ("div", plain (fn (x, y) => Tokens.MULSYM (S.DIV, x, y))),
81 :     ("mod", plain (fn (x, y) => Tokens.MULSYM (S.MOD, x, y))),
82 :     ("andalso", plain Tokens.ANDALSO),
83 :     ("orelse", plain Tokens.ORELSE),
84 :     ("not", plain Tokens.NOT)]
85 : blume 274
86 : mblume 1644 fun idToken (t, p, idlist, default, chstate, in_section2) =
87 : blume 274 case List.find (fn (id, _) => id = t) ml_ids of
88 :     SOME (_, tok) => (chstate (); tok (p, p + size t))
89 :     | NONE =>
90 :     (case List.find (fn (id, _) => id = t) idlist of
91 : mblume 1644 SOME (_, tok) => tok (in_section2, (p, p + size t))
92 : blume 274 | NONE => default (t, p, p + size t))
93 :    
94 : blume 265 (* states:
95 : blume 262
96 : blume 265 INITIAL -> C
97 :     |
98 :     +------> P -> PC
99 :     | |
100 :     | +--> PM -> PMC
101 :     |
102 :     +------> M -> MC
103 :     |
104 :     +------> S -> SS
105 :    
106 :     "C" -- COMMENT
107 :     "P" -- PREPROC
108 :     "M" -- MLSYMBOL
109 :     "S" -- STRING
110 :     "SS" -- STRINGSKIP
111 :     *)
112 :    
113 : blume 262 %%
114 :    
115 : blume 274 %s C P PC PM PMC M MC S SS;
116 : blume 265
117 : blume 262 %header(functor CMLexFun (structure Tokens: CM_TOKENS));
118 :    
119 : blume 265 %arg ({ enterC, leaveC,
120 :     newS, addS, addSC, addSN, getS,
121 :     handleEof,
122 :     newline,
123 : blume 397 obsolete,
124 : blume 313 error,
125 : mblume 1644 sync,
126 :     in_section2 });
127 : blume 265
128 : blume 262 idchars=[A-Za-z'_0-9];
129 :     id=[A-Za-z]{idchars}*;
130 : blume 274 cmextrachars=[.;,!%&$+/<=>?@~|#*]|\-|\^;
131 : blume 265 cmidchars={idchars}|{cmextrachars};
132 : blume 274 cmid={cmidchars}+;
133 : blume 262 ws=("\012"|[\t\ ]);
134 :     eol=("\013\010"|"\013"|"\010");
135 : blume 274 neol=[^\013\010];
136 : blume 262 sym=[!%&$+/:<=>?@~|#*]|\-|\^|"\\";
137 :     digit=[0-9];
138 :     sharp="#";
139 :     %%
140 :    
141 : blume 265 <INITIAL>"(*" => (enterC (); YYBEGIN C; continue ());
142 :     <P>"(*" => (enterC (); YYBEGIN PC; continue ());
143 :     <PM>"(*" => (enterC (); YYBEGIN PMC; continue ());
144 :     <M>"(*" => (enterC (); YYBEGIN MC; continue ());
145 :    
146 :     <C,PC,PMC,MC>"(*" => (enterC (); continue ());
147 :    
148 :     <C>"*)" => (if leaveC () then YYBEGIN INITIAL else ();
149 : blume 262 continue ());
150 : blume 265 <PC>"*)" => (if leaveC () then YYBEGIN P else ();
151 :     continue ());
152 :     <PMC>"*)" => (if leaveC () then YYBEGIN PM else ();
153 :     continue ());
154 :     <MC>"*)" => (if leaveC () then YYBEGIN M else ();
155 :     continue ());
156 :     <C,PC,PMC,MC>{eol} => (newline yypos; continue ());
157 :     <C,PC,PMC,MC>. => (continue ());
158 : blume 262
159 : blume 268 <INITIAL,P,PM,M>"*)" => (error (yypos, yypos+2)
160 :     "unmatched comment delimiter";
161 : blume 265 continue ());
162 : blume 262
163 : blume 294 <INITIAL>"\"" => (YYBEGIN S; newS yypos; continue ());
164 : blume 262
165 : blume 265 <S>"\\a" => (addS #"\a"; continue ());
166 :     <S>"\\b" => (addS #"\b"; continue ());
167 :     <S>"\\f" => (addS #"\f"; continue ());
168 :     <S>"\\n" => (addS #"\n"; continue ());
169 :     <S>"\\r" => (addS #"\r"; continue ());
170 :     <S>"\\t" => (addS #"\t"; continue ());
171 :     <S>"\\v" => (addS #"\v"; continue ());
172 : blume 262
173 : blume 265 <S>"\\^"@ => (addS (chr 0); continue ());
174 :     <S>"\\^"[a-z] => (addSC (yytext, ord #"a"); continue ());
175 :     <S>"\\^"[A-Z] => (addSC (yytext, ord #"A"); continue ());
176 :     <S>"\\^[" => (addS (chr 27); continue ());
177 :     <S>"\\^\\" => (addS (chr 28); continue ());
178 :     <S>"\\^]" => (addS (chr 29); continue ());
179 :     <S>"\\^^" => (addS (chr 30); continue ());
180 :     <S>"\\^_" => (addS (chr 31); continue ());
181 : blume 262
182 : blume 265 <S>"\\"[0-9][0-9][0-9] => (addSN (yytext, yypos); continue ());
183 : blume 262
184 : blume 265 <S>"\\\"" => (addS #"\""; continue ());
185 :     <S>"\\\\" => (addS #"\\"; continue ());
186 :    
187 :     <S>"\\"{eol} => (YYBEGIN SS; newline (yypos + 1); continue ());
188 :     <S>"\\"{ws}+ => (YYBEGIN SS; continue ());
189 :    
190 : blume 268 <S>"\\". => (error (yypos, yypos+2)
191 : blume 262 ("illegal escape character in string " ^ yytext);
192 :     continue ());
193 :    
194 : blume 266 <S>"\"" => (YYBEGIN INITIAL; getS (yypos, Tokens.FILE_NATIVE));
195 : blume 265 <S>{eol} => (newline yypos;
196 : blume 268 error (yypos, yypos + size yytext)
197 :     "illegal linebreak in string";
198 : blume 262 continue ());
199 :    
200 : blume 265 <S>. => (addS (String.sub (yytext, 0)); continue ());
201 :    
202 :     <SS>{eol} => (newline yypos; continue ());
203 :     <SS>{ws}+ => (continue ());
204 :     <SS>"\\" => (YYBEGIN S; continue ());
205 : blume 268 <SS>. => (error (yypos, yypos+1)
206 : blume 262 ("illegal character in stringskip " ^ yytext);
207 :     continue ());
208 :    
209 : blume 265 <INITIAL,P>"(" => (Tokens.LPAREN (yypos, yypos + 1));
210 :     <INITIAL,P>")" => (Tokens.RPAREN (yypos, yypos + 1));
211 : blume 262 <INITIAL>":" => (Tokens.COLON (yypos, yypos + 1));
212 : blume 632 <P>"+" => (Tokens.ADDSYM (S.PLUS, yypos, yypos + 1));
213 :     <P>"-" => (Tokens.ADDSYM (S.MINUS, yypos, yypos + 1));
214 :     <P>"*" => (Tokens.MULSYM (S.TIMES, yypos, yypos + 1));
215 :     <P>"<>" => (Tokens.EQSYM (S.NE, yypos, yypos + 2));
216 : blume 397 <P>"!=" => (obsolete (yypos, yypos + 2);
217 : blume 632 Tokens.EQSYM (S.NE, yypos, yypos+2));
218 :     <P>"<=" => (Tokens.INEQSYM (S.LE, yypos, yypos + 2));
219 :     <P>"<" => (Tokens.INEQSYM (S.LT, yypos, yypos + 1));
220 :     <P>">=" => (Tokens.INEQSYM (S.GE, yypos, yypos + 2));
221 :     <P>">" => (Tokens.INEQSYM (S.GT, yypos, yypos + 1));
222 : blume 397 <P>"==" => (obsolete (yypos, yypos + 2);
223 : blume 632 Tokens.EQSYM (S.EQ, yypos, yypos + 2));
224 :     <P>"=" => (Tokens.EQSYM (S.EQ, yypos, yypos + 1));
225 : blume 265 <P>"~" => (Tokens.TILDE (yypos, yypos + 1));
226 : blume 262
227 : blume 265 <P>{digit}+ => (Tokens.NUMBER
228 : blume 262 (valOf (Int.fromString yytext)
229 :     handle _ =>
230 : blume 268 (error (yypos, yypos + size yytext)
231 :     "number too large";
232 :     0),
233 : blume 262 yypos, yypos + size yytext));
234 :    
235 : blume 274 <P>{id} => (idToken (yytext, yypos, pp_ids, Tokens.CM_ID,
236 : mblume 1644 fn () => YYBEGIN PM, in_section2));
237 : blume 397 <P>"/" => (obsolete (yypos, yypos + 1);
238 : blume 632 Tokens.MULSYM (S.DIV, yypos, yypos + 1));
239 : blume 397 <P>"%" => (obsolete (yypos, yypos + 1);
240 : blume 632 Tokens.MULSYM (S.MOD, yypos, yypos + 1));
241 : blume 397 <P>"&&" => (obsolete (yypos, yypos + 2);
242 :     Tokens.ANDALSO (yypos, yypos + 2));
243 :     <P>"||" => (obsolete (yypos, yypos + 2);
244 :     Tokens.ORELSE (yypos, yypos + 2));
245 :     <P>"!" => (obsolete (yypos, yypos + 1);
246 :     Tokens.NOT (yypos, yypos + 1));
247 : blume 265
248 :     <M>({id}|{sym}+) => (YYBEGIN INITIAL;
249 :     Tokens.ML_ID (yytext, yypos, yypos + size yytext));
250 :     <PM>({id}|{sym}+) => (YYBEGIN P;
251 :     Tokens.ML_ID (yytext, yypos, yypos + size yytext));
252 :    
253 : blume 274 <INITIAL,P>{eol}{sharp}{ws}*"if" => (YYBEGIN P;
254 : blume 265 newline yypos;
255 :     Tokens.IF (yypos, yypos + size yytext));
256 : blume 274 <INITIAL,P>{eol}{sharp}{ws}*"elif" => (YYBEGIN P;
257 : blume 265 newline yypos;
258 :     Tokens.ELIF (yypos, yypos + size yytext));
259 : blume 274 <INITIAL,P>{eol}{sharp}{ws}*"else" => (YYBEGIN P;
260 : blume 265 newline yypos;
261 :     Tokens.ELSE (yypos, yypos + size yytext));
262 : blume 274 <INITIAL,P>{eol}{sharp}{ws}*"endif" => (YYBEGIN P;
263 : blume 265 newline yypos;
264 :     Tokens.ENDIF (yypos,
265 : blume 262 yypos + size yytext));
266 : blume 274 <INITIAL,P>{eol}{sharp}{ws}*"error"{ws}+{neol}* => (newline yypos;
267 :     errorTok (yytext, yypos));
268 : blume 265 <INITIAL,M,PM>{eol} => (newline yypos; continue ());
269 :     <P>{eol} => (YYBEGIN INITIAL; newline yypos; continue ());
270 :    
271 :     <INITIAL,M,PM,P>{ws}+ => (continue ());
272 :    
273 : blume 268 <M,PM>. => (error (yypos, yypos+1)
274 : blume 265 ("illegal character at start of ML symbol: " ^
275 :     yytext);
276 : blume 262 continue ());
277 : blume 265
278 : mblume 1644 <INITIAL>{cmid} => (idToken (yytext, yypos,
279 :     if !in_section2 then [] else cm_ids,
280 : blume 274 Tokens.FILE_STANDARD,
281 : mblume 1644 fn () => YYBEGIN M, in_section2));
282 : blume 265
283 :    
284 : blume 268 <INITIAL>. => (error (yypos, yypos+1)
285 : blume 265 ("illegal character: " ^ yytext);
286 :     continue ());
287 : blume 313
288 :     {eol}{sharp}{ws}*"line"{ws}+{neol}* => (newline yypos;
289 :     sync (yypos, yytext);
290 :     continue ());

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