1 COMPILER CR (*H.Moessenboeck 17.11.93, Coco/R*)
3 (*---------------------- semantic declarations ----------------------------*)
5 IMPORT CRT, CRA, CRX, Sets, Texts, Oberon;
7 CONST
8 ident = 0; string = 1; (*symbol kind*)
10 VAR
11 str: ARRAY 32 OF CHAR;
12 w: Texts.Writer;
13 genScanner: BOOLEAN;
16 PROCEDURE SemErr(nr: INTEGER);
17 BEGIN
18 CRS.Error(200+nr, CRS.pos);
19 END SemErr;
21 PROCEDURE MatchLiteral(sp: INTEGER); (*store string either as token or as literal*)
22 VAR sn, sn1: CRT.SymbolNode; matchedSp: INTEGER;
23 BEGIN
24 CRT.GetSym(sp, sn);
25 CRA.MatchDFA(sn.name, sp, matchedSp);
26 IF matchedSp # CRT.noSym THEN
27 CRT.GetSym(matchedSp, sn1); sn1.struct := CRT.classLitToken; CRT.PutSym(matchedSp, sn1);
28 sn.struct := CRT.litToken
29 ELSE sn.struct := CRT.classToken;
30 END;
31 CRT.PutSym(sp, sn)
32 END MatchLiteral;
34 PROCEDURE SetCtx(gp: INTEGER); (*set transition code to CRT.contextTrans*)
35 VAR gn: CRT.GraphNode;
36 BEGIN
37 WHILE gp > 0 DO
38 CRT.GetNode(gp, gn);
39 IF gn.typ IN {CRT.char, CRT.class} THEN
40 gn.p2 := CRT.contextTrans; CRT.PutNode(gp, gn)
41 ELSIF gn.typ IN {CRT.opt, CRT.iter} THEN SetCtx(gn.p1)
42 ELSIF gn.typ = CRT.alt THEN SetCtx(gn.p1); SetCtx(gn.p2)
43 END;
44 gp := gn.next
45 END
46 END SetCtx;
48 PROCEDURE SetDDT(s: ARRAY OF CHAR);
49 VAR name: ARRAY 64 OF CHAR; i: INTEGER; ch: CHAR;
50 BEGIN
51 i := 1;
52 WHILE s[i] # 0X DO
53 ch := s[i]; INC(i);
54 IF (ch >= "0") & (ch <= "9") THEN CRT.ddt[ORD(ch)-ORD("0")] := TRUE END
55 END
56 END SetDDT;
58 PROCEDURE FixString (VAR s: ARRAY OF CHAR; len: INTEGER);
59 VAR double: BOOLEAN; i: INTEGER;
60 BEGIN
61 double := FALSE;
62 FOR i := 0 TO len-2 DO
63 IF s[i] = '"' THEN double := TRUE END
64 END;
65 IF ~ double THEN s[0] := '"'; s[len-1] := '"' END
66 END FixString;
68 (*-------------------------------------------------------------------------*)
69 CHARACTERS
70 letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
71 digit = "0123456789".
72 eol = CHR(13).
73 tab = CHR(9).
74 noQuote1 = ANY - '"' - eol.
75 noQuote2 = ANY - "'" - eol.
77 IGNORE eol + tab + CHR(28)
80 TOKENS
81 ident = letter {letter | digit}.
82 string = '"' {noQuote1} '"' | "'" {noQuote2} "'".
83 number = digit {digit}.
86 PRAGMAS
87 ddtSym = "$" {digit}. (. CRS.GetName(CRS.nextPos, CRS.nextLen, str); SetDDT(str) .)
90 COMMENTS FROM "(*" TO "*)" NESTED
92 (*-------------------------------------------------------------------------*)
93 PRODUCTIONS
95 CR (. VAR undef, hasAttrs, ok, ok1: BOOLEAN; eofSy, gR: INTEGER;
96 gramLine, sp: INTEGER;
97 gn: CRT.GraphNode; sn: CRT.SymbolNode;
98 name, gramName: CRT.Name; .)
99 =
100 "COMPILER" (. Texts.OpenWriter(w);
101 CRT.Init; CRX.Init; CRA.Init;
102 gramLine := CRS.line;
103 eofSy := CRT.NewSym(CRT.t, "EOF", 0);
104 genScanner := TRUE;
105 CRT.ignoreCase := FALSE;
106 ok := TRUE;
107 Sets.Clear(CRT.ignored) .)
108 ident (. CRS.GetName(CRS.pos, CRS.len, gramName);
109 CRT.semDeclPos.beg := CRS.nextPos; CRT.importPos.beg := -1; .)
110 { "IMPORT" (. CRT.importPos.beg := CRS.nextPos .)
111 {ANY} ";" (. CRT.importPos.len := SHORT(CRS.pos - CRT.importPos.beg);
112 CRT.importPos.col := 0;
113 CRT.semDeclPos.beg := CRS.nextPos .)
114 | ANY
115 } (. CRT.semDeclPos.len := SHORT(CRS.nextPos - CRT.semDeclPos.beg);
116 CRT.semDeclPos.col := 0 .)
117 { Declaration }
118 SYNC
119 "PRODUCTIONS" (. IF genScanner THEN CRA.MakeDeterministic(ok) END;
120 CRT.nNodes := 0 .)
121 { ident (. CRS.GetName(CRS.pos, CRS.len, name);
122 sp := CRT.FindSym(name); undef := sp = CRT.noSym;
123 IF undef THEN
124 sp := CRT.NewSym(CRT.nt, name, CRS.line);
125 CRT.GetSym(sp, sn);
126 ELSE
127 CRT.GetSym(sp, sn);
128 IF sn.typ = CRT.nt THEN
129 IF sn.struct > 0 THEN SemErr(7) END
130 ELSE SemErr(8)
131 END;
132 sn.line := CRS.line
133 END;
134 hasAttrs := sn.attrPos.beg >= 0 .)
135 ( Attribs <sn.attrPos> (. IF ~undef & ~hasAttrs THEN SemErr(9) END;
136 CRT.PutSym(sp, sn) .)
137 | (. IF ~undef & hasAttrs THEN SemErr(10) END .)
138 )
139 [ SemText <sn.semPos>]
140 WEAK "="
141 Expression <sn.struct, gR> (. CRT.CompleteGraph(gR); CRT.PutSym(sp, sn);
142 IF CRT.ddt[2] THEN CRT.PrintGraph END .)
143 WEAK "."
144 } (. sp := CRT.FindSym(gramName);
145 IF sp = CRT.noSym THEN SemErr(11);
146 ELSE
147 CRT.GetSym(sp, sn);
148 IF sn.attrPos.beg >= 0 THEN SemErr(12) END;
149 CRT.root := CRT.NewNode(CRT.nt, sp, gramLine);
150 END .)
151 "END" ident (. CRS.GetName(CRS.pos, CRS.len, name);
152 IF name # gramName THEN SemErr(17) END;
153 IF CRS.errors = 0 THEN
154 Texts.WriteString(w, " checking"); Texts.Append(Oberon.Log, w.buf);
155 CRT.CompSymbolSets;
156 IF ok THEN CRT.TestCompleteness(ok) END;
157 IF ok THEN
158 CRT.TestIfAllNtReached(ok1); CRT.FindCircularProductions(ok)
159 END;
160 IF ok THEN CRT.TestIfNtToTerm(ok) END;
161 IF ok THEN CRT.LL1Test(ok1) END;
162 IF CRT.ddt[0] THEN CRA.PrintStates END;
163 IF CRT.ddt[7] THEN CRT.XRef END;
164 IF ok THEN
165 Texts.WriteString(w, " +parser");
166 Texts.Append(Oberon.Log, w.buf);
167 CRX.GenCompiler;
168 IF genScanner THEN
169 Texts.WriteString(w, " +scanner");
170 Texts.Append(Oberon.Log, w.buf);
171 CRA.WriteScanner
172 END;
173 IF CRT.ddt[8] THEN CRX.WriteStatistics END
174 END
175 ELSE ok := FALSE
176 END;
177 IF CRT.ddt[6] THEN CRT.PrintSymbolTable END;
178 IF ok THEN Texts.WriteString(w, " done") END;
179 Texts.WriteLn(w); Texts.Append(Oberon.Log, w.buf) .)
180 ".".
181 (*------------------------------------------------------------------------------------*)
182 Declaration (. VAR gL1, gR1, gL2, gR2: INTEGER; nested: BOOLEAN; .)
183 =
184 "CHARACTERS" { SetDecl }
185 | "TOKENS" { TokenDecl <CRT.t> }
186 | "PRAGMAS" { TokenDecl <CRT.pr> }
187 | "COMMENTS"
188 "FROM" TokenExpr <gL1, gR1>
189 "TO" TokenExpr <gL2, gR2>
190 ( "NESTED" (. nested := TRUE .)
191 | (. nested := FALSE .)
192 ) (. CRA.NewComment(gL1, gL2, nested) .)
193 | "IGNORE"
194 ( "CASE" (. CRT.ignoreCase := TRUE .)
195 | Set <CRT.ignored>
196 )
197 .
199 (*------------------------------------------------------------------------------------*)
200 SetDecl (. VAR c: INTEGER; set: CRT.Set; name: CRT.Name; .)
201 =
202 ident (. CRS.GetName(CRS.pos, CRS.len, name);
203 c := CRT.ClassWithName(name); IF c >= 0 THEN SemErr(7) END .)
204 "=" Set <set> (. c := CRT.NewClass(name, set) .)
205 ".".
206 (*------------------------------------------------------------------------------------*)
207 Set <VAR set: CRT.Set> (. VAR set2: CRT.Set; .)
208 =
209 SimSet <set>
210 { "+" SimSet <set2> (. Sets.Unite(set, set2) .)
211 | "-" SimSet <set2> (. Sets.Differ(set, set2) .)
212 }.
213 (*------------------------------------------------------------------------------------*)
214 SimSet <VAR set: CRT.Set> (. VAR c, n, i: INTEGER; name: CRT.Name; s: ARRAY 128 OF CHAR; .)
215 =
216 ident (. CRS.GetName(CRS.pos, CRS.len, name);
217 c := CRT.ClassWithName(name);
218 IF c < 0 THEN SemErr(15); Sets.Clear(set)
219 ELSE CRT.GetClass(c, set)
220 END .)
221 | string (. CRS.GetName(CRS.pos, CRS.len, s);
222 Sets.Clear(set); i := 1;
223 WHILE s[i] # s[0] DO
224 Sets.Incl(set, ORD(s[i])); INC(i)
225 END .)
226 | "CHR" "(" number (. CRS.GetName(CRS.pos, CRS.len, name);
227 n := 0; i := 0;
228 WHILE name[i] # 0X DO
229 n := 10 * n + (ORD(name[i]) - ORD("0"));
230 INC(i)
231 END;
232 Sets.Clear(set); Sets.Incl(set, n) .)
233 ")"
234 | "ANY" (. Sets.Fill(set) .)
235 .
236 (*------------------------------------------------------------------------------------*)
237 TokenDecl <typ: INTEGER> (. VAR sp, kind, gL, gR: INTEGER; sn: CRT.SymbolNode;
238 pos: CRT.Position; name: CRT.Name; .)
239 =
240 Symbol <name, kind> (. IF CRT.FindSym(name) # CRT.noSym THEN SemErr(7)
241 ELSE
242 sp := CRT.NewSym(typ, name, CRS.line);
243 CRT.GetSym(sp, sn); sn.struct := CRT.classToken;
244 CRT.PutSym(sp, sn)
245 END .)
246 SYNC
247 ( "=" TokenExpr <gL, gR> "." (. IF kind # ident THEN SemErr(13) END;
248 CRT.CompleteGraph(gR);
249 CRA.ConvertToStates(gL, sp) .)
250 | (. IF kind = ident THEN genScanner := FALSE
251 ELSE MatchLiteral(sp)
252 END .)
253 )
254 [ SemText <pos> (. IF typ = CRT.t THEN SemErr(14) END;
255 CRT.GetSym(sp, sn); sn.semPos := pos; CRT.PutSym(sp, sn) .)
256 ].
257 (*------------------------------------------------------------------------------------*)
258 Expression <VAR gL, gR: INTEGER> (. VAR gL2, gR2: INTEGER; first: BOOLEAN; .)
259 =
260 Term <gL, gR> (. first := TRUE .)
261 { WEAK "|"
262 Term <gL2, gR2> (. IF first THEN
263 CRT.MakeFirstAlt(gL, gR); first := FALSE
264 END;
265 CRT.ConcatAlt(gL, gR, gL2, gR2) .)
266 }.
267 (*------------------------------------------------------------------------------------*)
268 Term<VAR gL, gR: INTEGER> (. VAR gL2, gR2: INTEGER; .)
269 = (. gL := 0; gR := 0 .)
270 ( Factor <gL, gR>
271 { Factor <gL2, gR2> (. CRT.ConcatSeq(gL, gR, gL2, gR2) .)
272 }
273 | (. gL := CRT.NewNode(CRT.eps, 0, 0); gR := gL .)
274 ).
275 (*------------------------------------------------------------------------------------*)
276 Factor <VAR gL, gR: INTEGER> (. VAR sp, kind, c: INTEGER; name: CRT.Name;
277 gn: CRT.GraphNode; sn: CRT.SymbolNode;
278 set: CRT.Set;
279 undef, weak: BOOLEAN;
280 pos: CRT.Position; .)
281 =
282 (. gL :=0; gR := 0; weak := FALSE .)
283 ( [ "WEAK" (. weak := TRUE .)
284 ]
285 Symbol <name, kind> (. sp := CRT.FindSym(name); undef := sp = CRT.noSym;
286 IF undef THEN
287 IF kind = ident THEN (*forward nt*)
288 sp := CRT.NewSym(CRT.nt, name, 0)
289 ELSE (*undefined string in production*)
290 sp := CRT.NewSym(CRT.t, name, CRS.line);
291 MatchLiteral(sp)
292 END
293 END;
294 CRT.GetSym(sp, sn);
295 IF ~(sn.typ IN {CRT.t,CRT.nt}) THEN SemErr(4) END;
296 IF weak THEN
297 IF sn.typ = CRT.t THEN sn.typ := CRT.wt ELSE SemErr(23) END
298 END;
299 gL := CRT.NewNode(sn.typ, sp, CRS.line); gR := gL .)
301 ( Attribs <pos> (. CRT.GetNode(gL, gn); gn.pos := pos; CRT.PutNode(gL, gn);
302 CRT.GetSym(sp, sn);
303 IF undef THEN
304 sn.attrPos := pos; CRT.PutSym(sp, sn)
305 ELSIF sn.attrPos.beg < 0 THEN SemErr(5)
306 END;
307 IF kind # ident THEN SemErr(3) END .)
308 | (. CRT.GetSym(sp, sn);
309 IF sn.attrPos.beg >= 0 THEN SemErr(6) END .)
310 )
311 | "(" Expression <gL, gR> ")"
312 | "[" Expression <gL, gR> "]" (. CRT.MakeOption(gL, gR) .)
313 | "{" Expression <gL, gR> "}" (. CRT.MakeIteration(gL, gR) .)
314 | SemText <pos> (. gL := CRT.NewNode(CRT.sem, 0, 0);
315 gR := gL;
316 CRT.GetNode(gL, gn); gn.pos := pos; CRT.PutNode(gL, gn) .)
317 | "ANY" (. Sets.Fill(set); Sets.Excl(set, CRT.eofSy);
318 gL := CRT.NewNode(CRT.any, CRT.NewSet(set), 0); gR := gL .)
319 | "SYNC" (. gL := CRT.NewNode(CRT.sync, 0, 0); gR := gL .)
320 ).
321 (*------------------------------------------------------------------------------------*)
322 TokenExpr <VAR gL, gR: INTEGER> (. VAR gL2, gR2: INTEGER; first: BOOLEAN; .)
323 =
324 TokenTerm <gL, gR> (. first := TRUE .)
325 { WEAK "|"
326 TokenTerm <gL2, gR2> (. IF first THEN
327 CRT.MakeFirstAlt(gL, gR); first := FALSE
328 END;
329 CRT.ConcatAlt(gL, gR, gL2, gR2) .)
330 }.
331 (*------------------------------------------------------------------------------------*)
332 TokenTerm <VAR gL, gR: INTEGER> (. VAR gL2, gR2: INTEGER; .)
333 =
334 TokenFactor <gL, gR>
335 { TokenFactor <gL2, gR2> (. CRT.ConcatSeq(gL, gR, gL2, gR2) .)
336 }
337 [ "CONTEXT"
338 "(" TokenExpr <gL2, gR2> (. SetCtx(gL2); CRT.ConcatSeq(gL, gR, gL2, gR2) .)
339 ")"
340 ].
341 (*------------------------------------------------------------------------------------*)
342 TokenFactor <VAR gL, gR: INTEGER> (. VAR kind, c: INTEGER; set: CRT.Set; name: CRT.Name; .)
343 =
344 (. gL :=0; gR := 0 .)
345 ( Symbol <name, kind> (. IF kind = ident THEN
346 c := CRT.ClassWithName(name);
347 IF c < 0 THEN
348 SemErr(15);
349 Sets.Clear(set); c := CRT.NewClass(name, set)
350 END;
351 gL := CRT.NewNode(CRT.class, c, 0); gR := gL
352 ELSE (*string*)
353 CRT.StrToGraph(name, gL, gR)
354 END .)
355 | "(" TokenExpr <gL, gR> ")"
356 | "[" TokenExpr <gL, gR> "]" (. CRT.MakeOption(gL, gR) .)
357 | "{" TokenExpr <gL, gR> "}" (. CRT.MakeIteration(gL, gR) .)
358 ).
359 (*------------------------------------------------------------------------------------*)
360 Symbol <VAR name: CRT.Name; VAR kind: INTEGER> =
361 ( ident (. kind := ident .)
362 | string (. kind := string .)
363 ) (. CRS.GetName(CRS.pos, CRS.len, name);
364 IF kind = string THEN FixString(name, CRS.len) END .) .
365 (*------------------------------------------------------------------------------------*)
366 Attribs <VAR attrPos: CRT.Position> =
367 "<" (. attrPos.beg := CRS.nextPos; attrPos.col := CRS.nextCol .)
368 { ANY }
369 ">" (. attrPos.len := SHORT(CRS.pos - attrPos.beg) .).
370 (*------------------------------------------------------------------------------------*)
371 SemText <VAR semPos: CRT.Position> =
372 "(." (. semPos.beg := CRS.nextPos; semPos.col := CRS.nextCol .)
373 { ANY }
374 ".)" (. semPos.len := SHORT(CRS.pos - semPos.beg) .).
376 END CR.