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

Annotation of /sml/trunk/src/cm/parse/cm.lex

Parent Directory Parent Directory | Revision Log Revision Log


Revision 268 - (view) (download)

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

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