|
|
@@ -15,15 +15,1906 @@ Undefined nonterminals: -- none --
|
|
|
Unreachable nonterminals: -- none --
|
|
|
Circular derivations: -- none --
|
|
|
Underivable nonterminals: -- none --
|
|
|
-LL(1) conditions: -- ok --
|
|
|
+LL(1) conditions:
|
|
|
+ LL(1) error in ArrayType: "OF" is the start & successor of a deletable structure
|
|
|
+
|
|
|
+Listing:
|
|
|
+
|
|
|
+ 1 COMPILER M2c
|
|
|
+ 2 (* Modula-2 program modules with procedures and composites, MC64 backend
|
|
|
+ 3 (see MGen for details).
|
|
|
+ 4
|
|
|
+ 5 - program module only, no DEFINITION / IMPLEMENTATION split
|
|
|
+ 6 - no local modules, no EXPORT, no PRIORITY
|
|
|
+ 7 - procedures: declarations (nested), value and VAR parameters,
|
|
|
+ 8 functions with RETURN, recursion, FORWARD headings;
|
|
|
+ 9 no procedure types/variables, no cones
|
|
|
+ 10 - composites (Phase 3): fixed ARRAYs (bounds, 1D/multi-D indexing,
|
|
|
+ 11 unchecked, byte-packed CHAR/BOOLEAN), RECORDs (field offsets,
|
|
|
+ 12 .field, WITH incl. nested), SETs (+ union, - difference,
|
|
|
+ 13 * intersection, inclusive .. ranges), POINTERs (NEW/DISPOSE via
|
|
|
+ 14 VM ALLOCATE, ^, NIL), strings (ARRAY OF CHAR literal assign).
|
|
|
+ 15 Open arrays deferred; whole array/record copy deferred except
|
|
|
+ 16 string literals; VAR actuals must be simple (no a[i]/p^/fields
|
|
|
+ 17 as VAR actuals, 233); value composite params rejected (230);
|
|
|
+ 18 composite function returns rejected (unchecked, avoid wrong LEAVE).
|
|
|
+ 19 - statements: assignment, procedure call, IF, CASE, WHILE,
|
|
|
+ 20 REPEAT, LOOP/EXIT, FOR, WITH, RETURN, NEW, DISPOSE
|
|
|
+ 21 - symbol table (SymTab) with static type checking: error codes
|
|
|
+ 22 200/201/202 and 210-224 (as before), plus 231 (procedure
|
|
|
+ 23 forward mismatch or missing body), 232 (bad RETURN), 233
|
|
|
+ 24 (invalid procedure call); same lenient rules (single pass,
|
|
|
+ 25 declare-before-use, except POINTER bases may be same-scope
|
|
|
+ 26 aliases with structural pointer compatibility in Assignable;
|
|
|
+ 27 INTEGER, CARDINAL and subranges form one
|
|
|
+ 28 integer family; no mixed INTEGER/REAL arithmetic; INTEGER
|
|
|
+ 29 assigns to REAL; 1-character literal is CHAR; InvalidType
|
|
|
+ 30 suppresses follow-on errors)
|
|
|
+ 31 - backend (MGen): single-module MC64 image <ModName>.MC4,
|
|
|
+ 32 runnable with mcint. Procedures take table entries 1..N
|
|
|
+ 33 (0 = module body), run with ENTER frames, called via ED
|
|
|
+ 34 (global), EC (directly nested) or EE (display walk); actuals
|
|
|
+ 35 evaluate left-to-right into temps, then push reversed.
|
|
|
+ 36 Lowered: scalar + composite globals/frame vars (multi-slot,
|
|
|
+ 37 byte sizes, field/element offsets), CONST literals,
|
|
|
+ 38 SET masks with literals/ranges/IN/=/#/+-/*; full scalar +
|
|
|
+ 39 composite expressions (scaled indexing via IdxScale, field
|
|
|
+ 40 via FieldAdd, deref via 41H/60H, byte ops 0DH/1DH for CHAR);
|
|
|
+ 41 control flow via E0/E1 jumps; composite assign via
|
|
|
+ 42 StoreIndir0/StoreByte (scalar elems) and copy_block (strings).
|
|
|
+ 43 The rest parses and type-checks
|
|
|
+ 44 but gets error 230: open arrays, whole array/record copy
|
|
|
+ 45 (except string literals), value composite params/returns,
|
|
|
+ 46 non-literal CONST expressions and BY steps,
|
|
|
+ 47 EXIT outside LOOP, imported names used as values.
|
|
|
+ 48 - test convention (the language has no I/O): a global
|
|
|
+ 49 VAR ExitCode : INTEGER;
|
|
|
+ 50 is printed as decimal + CRLF through an embedded helper;
|
|
|
+ 51 without it the program just ends.
|
|
|
+ 52 - known semantic edges: INTEGER DIV/MOD truncate toward zero;
|
|
|
+ 53 CARDINAL past MAXINT compares as signed; AND/OR are eager;
|
|
|
+ 54 REAL widens to binary64; unchecked ARRAY indexing (no DA/DB);
|
|
|
+ 55 NIL dereference reads 0 (no static check, no VM trap yet);
|
|
|
+ 56 CHAR/BOOLEAN arrays byte-packed (1 byte/elem, slots over-
|
|
|
+ 57 allocated 8x); at most 64 procedures, 64 actuals
|
|
|
+ 58 per call, 16 names per FP-section, 8-deep nested calls,
|
|
|
+ 59 8-deep WITH, 1024 slots max per type. *)
|
|
|
+ 60
|
|
|
+ 61 IMPORT SymTab, MGen;
|
|
|
+ 62
|
|
|
+ 63 CHARACTERS
|
|
|
+ 64 eol = CHR(13) .
|
|
|
+ 65 letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" .
|
|
|
+ 66 digit = "0123456789" .
|
|
|
+ 67 hexDigit = digit + "ABCDEF" .
|
|
|
+ 68 noQuote1 = ANY - "'" - eol .
|
|
|
+ 69 noQuote2 = ANY - '"' - eol .
|
|
|
+ 70
|
|
|
+ 71 IGNORE CHR(9) .. CHR(13)
|
|
|
+ 72
|
|
|
+ 73 COMMENTS
|
|
|
+ 74 FROM "(*" TO "*)" NESTED
|
|
|
+ 75
|
|
|
+ 76 TOKENS
|
|
|
+ 77 ident = letter { letter | digit } .
|
|
|
+ 78 integer = digit { digit }
|
|
|
+ 79 | digit { digit } CONTEXT("..")
|
|
|
+ 80 | digit { hexDigit } "H" .
|
|
|
+ 81 real = digit { digit } "." { digit }
|
|
|
+ 82 [ "E" [ "+" | "-" ] digit { digit } ] .
|
|
|
+ 83 string = "'" { noQuote1 } "'"
|
|
|
+ 84 | '"' { noQuote2 } '"' .
|
|
|
+ 85
|
|
|
+ 86 PRODUCTIONS
|
|
|
+ 87 M2c (. VAR m1, m2: SymTab.Name; .)
|
|
|
+ 88 = "MODULE"
|
|
|
+ 89 GetIdent<m1> (. SymTab.Init; MGen.OpenModule(m1);
|
|
|
+ 90 IF ~SymTab.Enter(m1, SymTab.KindModule)
|
|
|
+ 91 THEN SemError(200) END .)
|
|
|
+ 92 ";"
|
|
|
+ 93 { Import } Block<FALSE> GetIdent<m2>
|
|
|
+ 94 (. IF ~SymTab.Equal(m1, m2)
|
|
|
+ 95 THEN SemError(202) END .)
|
|
|
+ 96 "." (. IF SymTab.AnyForward() THEN
|
|
|
+ 97 SemError(231)
|
|
|
+ 98 END;
|
|
|
+ 99 MGen.EndModule;
|
|
|
+ 100 SymTab.PrintTable; .) .
|
|
|
+ 101 Import (. VAR n: SymTab.Name; .)
|
|
|
+ 102 = "FROM"
|
|
|
+ 103 GetIdent<n> (. IF ~SymTab.Enter(n, SymTab.KindImport)
|
|
|
+ 104 THEN SemError(200) END .)
|
|
|
+ 105 "IMPORT"
|
|
|
+ 106 ImportList ";"
|
|
|
+ 107 | "IMPORT"
|
|
|
+ 108 ImportList ";" .
|
|
|
+ 109 ImportList (. VAR n: SymTab.Name; .)
|
|
|
+ 110 = GetIdent<n> (. IF ~SymTab.Enter(n, SymTab.KindImport)
|
|
|
+ 111 THEN SemError(200) END .)
|
|
|
+ 112 { ","
|
|
|
+ 113 GetIdent<n> (. IF ~SymTab.Enter(n, SymTab.KindImport)
|
|
|
+ 114 THEN SemError(200) END .) } .
|
|
|
+ 115 Block <isProc: BOOLEAN> (. VAR began: BOOLEAN; .)
|
|
|
+ 116 = (. began := FALSE; .)
|
|
|
+ 117 { Declaration }
|
|
|
+ 118 [ "BEGIN" (. began := TRUE;
|
|
|
+ 119 IF isProc THEN
|
|
|
+ 120 MGen.ProcEntry(
|
|
|
+ 121 SymTab.CurProc(),
|
|
|
+ 122 SymTab.ProcNLocals())
|
|
|
+ 123 ELSE MGen.BeginBody
|
|
|
+ 124 END; .)
|
|
|
+ 125 StatSeq ]
|
|
|
+ 126 "END" (. IF isProc THEN
|
|
|
+ 127 IF ~began THEN
|
|
|
+ 128 MGen.ProcEntry(
|
|
|
+ 129 SymTab.CurProc(),
|
|
|
+ 130 SymTab.ProcNLocals())
|
|
|
+ 131 END;
|
|
|
+ 132 IF SymTab.InFunction() THEN
|
|
|
+ 133 MGen.PushInt(0)
|
|
|
+ 134 END;
|
|
|
+ 135 MGen.Leave(SymTab.CurNPar(),
|
|
|
+ 136 SymTab.InFunction())
|
|
|
+ 137 END; .) .
|
|
|
+ 138 Declaration = "CONST"
|
|
|
+ 139 {
|
|
|
+ 140 ConstDecl ";" }
|
|
|
+ 141 | "TYPE"
|
|
|
+ 142 {
|
|
|
+ 143 TypeDecl ";" }
|
|
|
+ 144 | "VAR"
|
|
|
+ 145 {
|
|
|
+ 146 VarDecl ";" }
|
|
|
+ 147 | ProcedureDecl ";" .
|
|
|
+ 148 ConstDecl (. VAR n: SymTab.Name;
|
|
|
+ 149 t: SymTab.TypeIndex;
|
|
|
+ 150 lx: MGen.LitStr;
|
|
|
+ 151 cls: INTEGER; .)
|
|
|
+ 152 = GetIdent<n> (. IF ~SymTab.Enter(n, SymTab.KindConst)
|
|
|
+ 153 THEN SemError(200) END .)
|
|
|
+ 154 "=" (. MGen.NoEmitEnter; .)
|
|
|
+ 155 ConstExpr<t, lx> (. SymTab.SetSymType(n, t);
|
|
|
+ 156 cls := SymTab.ClassOf(t);
|
|
|
+ 157 IF cls = SymTab.ClStr THEN
|
|
|
+ 158 SemError(230)
|
|
|
+ 159 ELSIF ~MGen.IsLit(lx) THEN
|
|
|
+ 160 SemError(230)
|
|
|
+ 161 END;
|
|
|
+ 162 MGen.DeclConst(n, lx, t);
|
|
|
+ 163 MGen.NoEmitExit; .) .
|
|
|
+ 164 ConstExpr <VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr>
|
|
|
+ 165 (. VAR vD: BOOLEAN;
|
|
|
+ 166 vnD: SymTab.Name; .)
|
|
|
+ 167 = Expr<t, lx, vD, vnD> .
|
|
|
+ 168 TypeDecl (. VAR n: SymTab.Name;
|
|
|
+ 169 t0, t1: SymTab.TypeIndex; .)
|
|
|
+ 170 = GetIdent<n> (. IF ~SymTab.Enter(n, SymTab.KindType)
|
|
|
+ 171 THEN SemError(200) END;
|
|
|
+ 172 t0 := SymTab.NewAlias();
|
|
|
+ 173 SymTab.SetSymType(n, t0); .)
|
|
|
+ 174 "="
|
|
|
+ 175 Type<t1> (. IF t1 = t0 THEN SemError(223);
|
|
|
+ 176 SymTab.SetTarget(t0,
|
|
|
+ 177 SymTab.InvalidType)
|
|
|
+ 178 ELSE SymTab.SetTarget(t0, t1) END; .) .
|
|
|
+ 179 VarDecl (. VAR t: SymTab.TypeIndex;
|
|
|
+ 180 i: CARDINAL;
|
|
|
+ 181 nm: SymTab.Name;
|
|
|
+ 182 cls: INTEGER;
|
|
|
+ 183 sl: CARDINAL; .)
|
|
|
+ 184 = VarIdents ":"
|
|
|
+ 185 Type<t> (. cls := SymTab.ClassOf(t);
|
|
|
+ 186 IF (cls # SymTab.ClInt)
|
|
|
+ 187 & (cls # SymTab.ClReal)
|
|
|
+ 188 & (cls # SymTab.ClBool)
|
|
|
+ 189 & (cls # SymTab.ClChar)
|
|
|
+ 190 & (cls # SymTab.ClEnum)
|
|
|
+ 191 & (cls # SymTab.ClSet)
|
|
|
+ 192 & (cls # SymTab.ClArray)
|
|
|
+ 193 & (cls # SymTab.ClRecord)
|
|
|
+ 194 & (cls # SymTab.ClPtr) THEN
|
|
|
+ 195 SemError(230)
|
|
|
+ 196 END;
|
|
|
+ 197 sl := SymTab.TypeSlots(t);
|
|
|
+ 198 IF sl = 0 THEN
|
|
|
+ 199 SemError(230);
|
|
|
+ 200 sl := 1
|
|
|
+ 201 END;
|
|
|
+ 202 i := 0;
|
|
|
+ 203 WHILE i < SymTab.PendCount() DO
|
|
|
+ 204 SymTab.PendName(i, nm);
|
|
|
+ 205 IF SymTab.SymDepth(nm) = 0 THEN
|
|
|
+ 206 MGen.DeclVarSized(nm, sl)
|
|
|
+ 207 END;
|
|
|
+ 208 INC(i)
|
|
|
+ 209 END;
|
|
|
+ 210 SymTab.FixPending(t); .) .
|
|
|
+ 211 VarIdents (. VAR n: SymTab.Name; .)
|
|
|
+ 212 = GetIdent<n> (. IF ~SymTab.EnterPending(n,
|
|
|
+ 213 SymTab.KindVar)
|
|
|
+ 214 THEN SemError(200) END .)
|
|
|
+ 215 { ","
|
|
|
+ 216 GetIdent<n> (. IF ~SymTab.EnterPending(n,
|
|
|
+ 217 SymTab.KindVar)
|
|
|
+ 218 THEN SemError(200) END .) } .
|
|
|
+ 219 ProcedureDecl (. VAR n, m: SymTab.Name;
|
|
|
+ 220 rt: SymTab.TypeIndex;
|
|
|
+ 221 hasR, ok: BOOLEAN;
|
|
|
+ 222 endL: INTEGER; .)
|
|
|
+ 223 = "PROCEDURE" (. hasR := FALSE; .)
|
|
|
+ 224 GetIdent<n> (. IF SymTab.IsForward(n) THEN
|
|
|
+ 225 SymTab.ReuseProc(n)
|
|
|
+ 226 ELSIF ~SymTab.EnterProc(n) THEN
|
|
|
+ 227 SemError(200)
|
|
|
+ 228 END;
|
|
|
+ 229 SymTab.OpenProcScope;
|
|
|
+ 230 endL := MGen.NewLabel();
|
|
|
+ 231 MGen.Jmp(endL); .)
|
|
|
+ 232 [ "(" FormalParams ")" ]
|
|
|
+ 233 [ ":" QualIdent<rt> (. hasR := TRUE; .) ]
|
|
|
+ 234 (. IF hasR THEN
|
|
|
+ 235 ok := SymTab.SetProcRet(rt)
|
|
|
+ 236 ELSE
|
|
|
+ 237 ok := SymTab.SetProcRet(
|
|
|
+ 238 SymTab.InvalidType)
|
|
|
+ 239 END;
|
|
|
+ 240 IF ~ok THEN SemError(231) END;
|
|
|
+ 241 IF ~SymTab.VerifyProc() THEN
|
|
|
+ 242 SemError(231)
|
|
|
+ 243 END; .)
|
|
|
+ 244 ";"
|
|
|
+ 245 ( Block<TRUE> GetIdent<m> (. IF ~SymTab.Equal(n, m) THEN
|
|
|
+ 246 SemError(202) END;
|
|
|
+ 247 MGen.DefLabel(endL);
|
|
|
+ 248 SymTab.CloseProc; .)
|
|
|
+ 249 | "FORWARD" (. SymTab.SetForward;
|
|
|
+ 250 SymTab.CloseProc;
|
|
|
+ 251 MGen.DefLabel(endL); .) ) .
|
|
|
+ 252 FormalParams = FPSection { ";" FPSection } .
|
|
|
+ 253 FPSection (. VAR isV: BOOLEAN;
|
|
|
+ 254 nn, i: CARDINAL;
|
|
|
+ 255 pn: ARRAY [0 .. 15] OF SymTab.Name;
|
|
|
+ 256 n: SymTab.Name;
|
|
|
+ 257 t: SymTab.TypeIndex; .)
|
|
|
+ 258 = (. isV := FALSE; nn := 0; .)
|
|
|
+ 259 [ "VAR" (. isV := TRUE; .) ]
|
|
|
+ 260 GetIdent<n> (. IF nn <= HIGH(pn) THEN
|
|
|
+ 261 MGen.CopyName(n, pn[nn])
|
|
|
+ 262 END;
|
|
|
+ 263 INC(nn); .)
|
|
|
+ 264 { "," GetIdent<n> (. IF nn <= HIGH(pn) THEN
|
|
|
+ 265 MGen.CopyName(n, pn[nn])
|
|
|
+ 266 END;
|
|
|
+ 267 INC(nn); .) }
|
|
|
+ 268 ":" Type<t> (. IF ~isV
|
|
|
+ 269 & (t # SymTab.InvalidType)
|
|
|
+ 270 & (SymTab.TypeSlots(t) > 1) THEN
|
|
|
+ 271 SemError(230)
|
|
|
+ 272 END;
|
|
|
+ 273 i := 0;
|
|
|
+ 274 WHILE i < nn DO
|
|
|
+ 275 IF i <= HIGH(pn) THEN
|
|
|
+ 276 IF ~SymTab.EnterParam(
|
|
|
+ 277 pn[i], isV, t) THEN
|
|
|
+ 278 SemError(200)
|
|
|
+ 279 END
|
|
|
+ 280 END;
|
|
|
+ 281 INC(i)
|
|
|
+ 282 END; .) .
|
|
|
+ 283 QualIdent <VAR t: SymTab.TypeIndex>
|
|
|
+ 284 (. VAR n, m: SymTab.Name; .)
|
|
|
+ 285 = GetIdent<n> (. IF ~SymTab.Lookup(n) THEN
|
|
|
+ 286 SemError(201);
|
|
|
+ 287 t := SymTab.InvalidType
|
|
|
+ 288 ELSIF (SymTab.SymKind(n) #
|
|
|
+ 289 SymTab.KindType)
|
|
|
+ 290 & (SymTab.SymKind(n) #
|
|
|
+ 291 SymTab.KindPredef)
|
|
|
+ 292 & (SymTab.SymKind(n) #
|
|
|
+ 293 SymTab.KindImport) THEN
|
|
|
+ 294 SemError(221);
|
|
|
+ 295 t := SymTab.InvalidType
|
|
|
+ 296 ELSE t := SymTab.SymType(n) END; .)
|
|
|
+ 297 { "."
|
|
|
+ 298 GetIdent<m> (. t := SymTab.InvalidType; .) } .
|
|
|
+ 299
|
|
|
+ 300 (* Types: ProcedureType removed; subrange factored for LL(1) *)
|
|
|
+ 301 Type <VAR t: SymTab.TypeIndex>
|
|
|
+ 302 = SimpleType<t> | ArrayType<t> | RecordType<t>
|
|
|
+ 303 | SetType<t> | PointerType<t> .
|
|
|
+ 304 SimpleType <VAR t: SymTab.TypeIndex>
|
|
|
+ 305 (. VAR t1, t2: SymTab.TypeIndex;
|
|
|
+ 306 lx1, lx2: MGen.LitStr;
|
|
|
+ 307 vD: BOOLEAN;
|
|
|
+ 308 vnD: SymTab.Name;
|
|
|
+ 309 loI, hiI: INTEGER;
|
|
|
+ 310 lok, hik: BOOLEAN; .)
|
|
|
+ 311 = QualIdent<t> [ "["
|
|
|
+ 312 (. MGen.NoEmitEnter; lok := FALSE; hik := FALSE;
|
|
|
+ 313 loI := 0; hiI := -1; .)
|
|
|
+ 314 ConstExpr<t1, lx1> (. IF (t1 # SymTab.InvalidType)
|
|
|
+ 315 & (SymTab.ClassOf(t1) #
|
|
|
+ 316 SymTab.ClInt)
|
|
|
+ 317 & (SymTab.ClassOf(t1) #
|
|
|
+ 318 SymTab.ClChar)
|
|
|
+ 319 & (SymTab.ClassOf(t1) #
|
|
|
+ 320 SymTab.ClEnum) THEN
|
|
|
+ 321 SemError(224) END; .)
|
|
|
+ 322 ".."
|
|
|
+ 323 ConstExpr<t2, lx2> (. IF (t2 # SymTab.InvalidType)
|
|
|
+ 324 & (SymTab.ClassOf(t2) #
|
|
|
+ 325 SymTab.ClInt)
|
|
|
+ 326 & (SymTab.ClassOf(t2) #
|
|
|
+ 327 SymTab.ClChar)
|
|
|
+ 328 & (SymTab.ClassOf(t2) #
|
|
|
+ 329 SymTab.ClEnum) THEN
|
|
|
+ 330 SemError(224) END; .)
|
|
|
+ 331 "]"
|
|
|
+ 332 (. IF (t1 # SymTab.InvalidType)
|
|
|
+ 333 & (t2 # SymTab.InvalidType) THEN
|
|
|
+ 334 IF MGen.IsLit(lx1) THEN
|
|
|
+ 335 IF SymTab.ClassOf(t1)
|
|
|
+ 336 = SymTab.ClChar THEN
|
|
|
+ 337 loI := MGen.CharOrd(lx1);
|
|
|
+ 338 lok := TRUE
|
|
|
+ 339 ELSIF MGen.ParseInt(lx1, loI) THEN
|
|
|
+ 340 lok := TRUE
|
|
|
+ 341 END
|
|
|
+ 342 END;
|
|
|
+ 343 IF MGen.IsLit(lx2) THEN
|
|
|
+ 344 IF SymTab.ClassOf(t2)
|
|
|
+ 345 = SymTab.ClChar THEN
|
|
|
+ 346 hiI := MGen.CharOrd(lx2);
|
|
|
+ 347 hik := TRUE
|
|
|
+ 348 ELSIF MGen.ParseInt(lx2, hiI) THEN
|
|
|
+ 349 hik := TRUE
|
|
|
+ 350 END
|
|
|
+ 351 END
|
|
|
+ 352 END;
|
|
|
+ 353 IF lok & hik THEN
|
|
|
+ 354 t := SymTab.NewSubB(t1, loI, hiI)
|
|
|
+ 355 ELSE
|
|
|
+ 356 t := SymTab.NewSub(t1);
|
|
|
+ 357 IF (t1 # SymTab.InvalidType)
|
|
|
+ 358 & (t2 # SymTab.InvalidType) THEN
|
|
|
+ 359 SemError(230)
|
|
|
+ 360 END
|
|
|
+ 361 END;
|
|
|
+ 362 MGen.NoEmitExit; .) ]
|
|
|
+ 363 | "[" (. MGen.NoEmitEnter; lok := FALSE;
|
|
|
+ 364 hik := FALSE; loI := 0; hiI := -1; .)
|
|
|
+ 365 ConstExpr<t1, lx1> (. IF (t1 # SymTab.InvalidType)
|
|
|
+ 366 & (SymTab.ClassOf(t1) #
|
|
|
+ 367 SymTab.ClInt)
|
|
|
+ 368 & (SymTab.ClassOf(t1) #
|
|
|
+ 369 SymTab.ClChar)
|
|
|
+ 370 & (SymTab.ClassOf(t1) #
|
|
|
+ 371 SymTab.ClEnum) THEN
|
|
|
+ 372 SemError(224) END; .)
|
|
|
+ 373 ".."
|
|
|
+ 374 ConstExpr<t2, lx2> (. IF (t2 # SymTab.InvalidType)
|
|
|
+ 375 & (SymTab.ClassOf(t2) #
|
|
|
+ 376 SymTab.ClInt)
|
|
|
+ 377 & (SymTab.ClassOf(t2) #
|
|
|
+ 378 SymTab.ClChar)
|
|
|
+ 379 & (SymTab.ClassOf(t2) #
|
|
|
+ 380 SymTab.ClEnum) THEN
|
|
|
+ 381 SemError(224) END; .)
|
|
|
+ 382 "]" (. IF (t1 # SymTab.InvalidType)
|
|
|
+ 383 & (t2 # SymTab.InvalidType) THEN
|
|
|
+ 384 IF MGen.IsLit(lx1) THEN
|
|
|
+ 385 IF SymTab.ClassOf(t1)
|
|
|
+ 386 = SymTab.ClChar THEN
|
|
|
+ 387 loI := MGen.CharOrd(lx1);
|
|
|
+ 388 lok := TRUE
|
|
|
+ 389 ELSIF MGen.ParseInt(lx1,
|
|
|
+ 390 loI) THEN
|
|
|
+ 391 lok := TRUE
|
|
|
+ 392 END
|
|
|
+ 393 END;
|
|
|
+ 394 IF MGen.IsLit(lx2) THEN
|
|
|
+ 395 IF SymTab.ClassOf(t2)
|
|
|
+ 396 = SymTab.ClChar THEN
|
|
|
+ 397 hiI := MGen.CharOrd(lx2);
|
|
|
+ 398 hik := TRUE
|
|
|
+ 399 ELSIF MGen.ParseInt(lx2,
|
|
|
+ 400 hiI) THEN
|
|
|
+ 401 hik := TRUE
|
|
|
+ 402 END
|
|
|
+ 403 END
|
|
|
+ 404 END;
|
|
|
+ 405 IF lok & hik THEN
|
|
|
+ 406 t := SymTab.NewSubB(t1, loI, hiI)
|
|
|
+ 407 ELSE
|
|
|
+ 408 t := SymTab.NewSub(t1);
|
|
|
+ 409 IF (t1 # SymTab.InvalidType)
|
|
|
+ 410 & (t2 # SymTab.InvalidType) THEN
|
|
|
+ 411 SemError(230)
|
|
|
+ 412 END
|
|
|
+ 413 END;
|
|
|
+ 414 MGen.NoEmitExit; .)
|
|
|
+ 415 | Enum<t> .
|
|
|
+ 416 Enum <VAR t: SymTab.TypeIndex>
|
|
|
+ 417 (. VAR n: SymTab.Name;
|
|
|
+ 418 ord: INTEGER; .)
|
|
|
+ 419 = "(" (. t := SymTab.NewEnum();
|
|
|
+ 420 ord := 0; .)
|
|
|
+ 421 GetIdent<n> (. IF ~SymTab.Enter(n,
|
|
|
+ 422 SymTab.KindConst)
|
|
|
+ 423 THEN SemError(200) END;
|
|
|
+ 424 SymTab.SetSymType(n, t);
|
|
|
+ 425 SymTab.EnumAdd(t);
|
|
|
+ 426 MGen.DeclConstInt(n, ord);
|
|
|
+ 427 INC(ord); .)
|
|
|
+ 428 { ","
|
|
|
+ 429 GetIdent<n> (. IF ~SymTab.Enter(n,
|
|
|
+ 430 SymTab.KindConst)
|
|
|
+ 431 THEN SemError(200) END;
|
|
|
+ 432 SymTab.SetSymType(n, t);
|
|
|
+ 433 SymTab.EnumAdd(t);
|
|
|
+ 434 MGen.DeclConstInt(n, ord);
|
|
|
+ 435 INC(ord); .) }
|
|
|
+ 436 ")" .
|
|
|
+ 437 ArrayType <VAR t: SymTab.TypeIndex>
|
|
|
+ 438 (. VAR s, s2, e: SymTab.TypeIndex;
|
|
|
+ 439 idx: ARRAY [0 .. 7] OF
|
|
|
+ 440 SymTab.TypeIndex;
|
|
|
+ 441 nc, kk: CARDINAL;
|
|
|
+ 442 loA, hiA: INTEGER;
|
|
|
+ 443 isOpenA: BOOLEAN; .)
|
|
|
+ 444 = "ARRAY"
|
|
|
+ 445 [ SimpleType<s> (. IF (s # SymTab.InvalidType)
|
|
|
+ 446 & (SymTab.ClassOf(s) #
|
|
|
+ 447 SymTab.ClInt)
|
|
|
+ 448 & (SymTab.ClassOf(s) #
|
|
|
+ 449 SymTab.ClChar)
|
|
|
+ 450 & (SymTab.ClassOf(s) #
|
|
|
+ 451 SymTab.ClEnum) THEN
|
|
|
+ 452 SemError(224) END;
|
|
|
+ 453 nc := 0; isOpenA := FALSE;
|
|
|
+ 454 idx[nc] := s; INC(nc); .)
|
|
|
+ 455 { ","
|
|
|
+ 456 SimpleType<s2> (. IF (s2 # SymTab.InvalidType)
|
|
|
+ 457 & (SymTab.ClassOf(s2) #
|
|
|
+ 458 SymTab.ClInt)
|
|
|
+ 459 & (SymTab.ClassOf(s2) #
|
|
|
+ 460 SymTab.ClChar)
|
|
|
+ 461 & (SymTab.ClassOf(s2) #
|
|
|
+ 462 SymTab.ClEnum) THEN
|
|
|
+ 463 SemError(224) END;
|
|
|
+ 464 IF nc <= HIGH(idx) THEN
|
|
|
+ 465 idx[nc] := s2; INC(nc)
|
|
|
+ 466 END; .) }
|
|
|
+ 467 | (. nc := 0; isOpenA := TRUE; .) ]
|
|
|
+ 468 "OF"
|
|
|
+ 469 Type<e> (. IF isOpenA THEN
|
|
|
+ 470 t := SymTab.NewOpen(e)
|
|
|
+ 471 ELSE
|
|
|
+ 472 t := e;
|
|
|
+ 473 kk := nc;
|
|
|
+ 474 WHILE kk > 0 DO
|
|
|
+ 475 DEC(kk);
|
|
|
+ 476 loA := SymTab.TypeLo(idx[kk]);
|
|
|
+ 477 hiA := SymTab.TypeHi(idx[kk]);
|
|
|
+ 478 IF SymTab.TypeLen(idx[kk]) = 0 THEN
|
|
|
+ 479 IF idx[kk]
|
|
|
+ 480 # SymTab.InvalidType THEN
|
|
|
+ 481 SemError(230)
|
|
|
+ 482 END;
|
|
|
+ 483 loA := 0; hiA := -1
|
|
|
+ 484 END;
|
|
|
+ 485 t := SymTab.NewArrayB(t,
|
|
|
+ 486 loA, hiA)
|
|
|
+ 487 END
|
|
|
+ 488 END; .) .
|
|
|
+ 489 RecordType <VAR t: SymTab.TypeIndex>
|
|
|
+ 490 = "RECORD" (. t := SymTab.NewRecord(); .)
|
|
|
+ 491 FieldSeq<t>
|
|
|
+ 492 "END" .
|
|
|
+ 493 FieldSeq <rt: SymTab.TypeIndex>
|
|
|
+ 494 = Field<rt> { ";"
|
|
|
+ 495 Field<rt> } .
|
|
|
+ 496 Field <rt: SymTab.TypeIndex>
|
|
|
+ 497 (. VAR et: SymTab.TypeIndex; .)
|
|
|
+ 498 = [ FieldIdents<rt> ":"
|
|
|
+ 499 Type<et> (. IF (et # SymTab.InvalidType)
|
|
|
+ 500 & SymTab.IsOpen(et) THEN
|
|
|
+ 501 SemError(230)
|
|
|
+ 502 END;
|
|
|
+ 503 SymTab.FixPendingF(rt, et); .) ] .
|
|
|
+ 504 FieldIdents <rt: SymTab.TypeIndex>
|
|
|
+ 505 (. VAR n: SymTab.Name; .)
|
|
|
+ 506 = GetIdent<n> (. IF ~SymTab.FieldPending(rt, n)
|
|
|
+ 507 THEN SemError(200) END .)
|
|
|
+ 508 { ","
|
|
|
+ 509 GetIdent<n> (. IF ~SymTab.FieldPending(rt, n)
|
|
|
+ 510 THEN SemError(200) END .) } .
|
|
|
+ 511 SetType <VAR t: SymTab.TypeIndex>
|
|
|
+ 512 (. VAR s: SymTab.TypeIndex; .)
|
|
|
+ 513 = "SET"
|
|
|
+ 514 "OF"
|
|
|
+ 515 SimpleType<s> (. IF (s # SymTab.InvalidType)
|
|
|
+ 516 & (SymTab.ClassOf(s) #
|
|
|
+ 517 SymTab.ClInt)
|
|
|
+ 518 & (SymTab.ClassOf(s) #
|
|
|
+ 519 SymTab.ClChar)
|
|
|
+ 520 & (SymTab.ClassOf(s) #
|
|
|
+ 521 SymTab.ClEnum) THEN
|
|
|
+ 522 SemError(224) END;
|
|
|
+ 523 t := SymTab.NewSet(s); .) .
|
|
|
+ 524 PointerType <VAR t: SymTab.TypeIndex>
|
|
|
+ 525 (. VAR b: SymTab.TypeIndex; .)
|
|
|
+ 526 = "POINTER"
|
|
|
+ 527 "TO"
|
|
|
+ 528 Type<b> (. t := SymTab.NewPtr(b); .) .
|
|
|
+ 529
|
|
|
+ 530 (* Statements: RETURN added; calls via AssignOrCall *)
|
|
|
+ 531 StatSeq = Stat { ";"
|
|
|
+ 532 Stat } .
|
|
|
+ 533 Stat (. VAR lx: INTEGER; .)
|
|
|
+ 534 = [ AssignOrCall | IfStat | CaseStat | WhileStat
|
|
|
+ 535 | RepeatStat | LoopStat | ForStat | WithStat | ReturnStat
|
|
|
+ 536 | NewStat | DispStat | WriteIntStat | WriteStrStat
|
|
|
+ 537 | "EXIT" (. IF MGen.TopLoop(lx) THEN
|
|
|
+ 538 MGen.Jmp(lx)
|
|
|
+ 539 ELSE SemError(230) END; .) ] .
|
|
|
+ 540 AssignOrCall (. VAR dt, et: SymTab.TypeIndex;
|
|
|
+ 541 dk: INTEGER;
|
|
|
+ 542 bn: SymTab.Name;
|
|
|
+ 543 lxD, lxe: MGen.LitStr;
|
|
|
+ 544 vE: BOOLEAN;
|
|
|
+ 545 vnE: SymTab.Name;
|
|
|
+ 546 sfx: BOOLEAN;
|
|
|
+ 547 okC: BOOLEAN;
|
|
|
+ 548 isR, conv,
|
|
|
+ 549 storable, pushedDst,
|
|
|
+ 550 pushedFld: BOOLEAN;
|
|
|
+ 551 dstBytes, srcBytes: CARDINAL;
|
|
|
+ 552 elemDt: SymTab.TypeIndex; .)
|
|
|
+ 553 = (. sfx := FALSE; pushedDst := FALSE;
|
|
|
+ 554 pushedFld := FALSE; .)
|
|
|
+ 555 DesignHead<dt, dk, bn, FALSE, lxD>
|
|
|
+ 556 ( DesignTail<dt, dk, bn, FALSE, lxD, sfx> ":="
|
|
|
+ 557 (. storable :=
|
|
|
+ 558 (dk = SymTab.KindVar)
|
|
|
+ 559 OR (dk = SymTab.KindParam)
|
|
|
+ 560 OR (dk = SymTab.KindVarPar);
|
|
|
+ 561 IF (dk = SymTab.KindField)
|
|
|
+ 562 & (~sfx)
|
|
|
+ 563 & (dt # SymTab.InvalidType) THEN
|
|
|
+ 564 MGen.WithAddr(bn);
|
|
|
+ 565 pushedFld := TRUE
|
|
|
+ 566 END;
|
|
|
+ 567 IF storable & ~sfx
|
|
|
+ 568 & (dt # SymTab.InvalidType)
|
|
|
+ 569 & ((SymTab.ClassOf(dt)
|
|
|
+ 570 = SymTab.ClArray)
|
|
|
+ 571 OR (SymTab.ClassOf(dt)
|
|
|
+ 572 = SymTab.ClRecord)) THEN
|
|
|
+ 573 MGen.PushAddr(bn);
|
|
|
+ 574 pushedDst := TRUE
|
|
|
+ 575 END;
|
|
|
+ 576 IF storable & ~sfx
|
|
|
+ 577 & ~pushedDst THEN
|
|
|
+ 578 IF (dt # SymTab.InvalidType)
|
|
|
+ 579 & (SymTab.TypeSlots(dt)
|
|
|
+ 580 > 1) THEN
|
|
|
+ 581 ELSE MGen.StoreSetup(bn)
|
|
|
+ 582 END
|
|
|
+ 583 END; .)
|
|
|
+ 584 Expr<et, lxe, vE, vnE> (. IF (dt # SymTab.InvalidType)
|
|
|
+ 585 & (dk # SymTab.KindVar)
|
|
|
+ 586 & (dk # SymTab.KindParam)
|
|
|
+ 587 & (dk # SymTab.KindVarPar)
|
|
|
+ 588 & (dk # SymTab.KindField)
|
|
|
+ 589 & (dk # SymTab.KindImport) THEN
|
|
|
+ 590 SemError(210)
|
|
|
+ 591 ELSIF pushedDst THEN
|
|
|
+ 592 IF et = SymTab.InvalidType THEN
|
|
|
+ 593 MGen.Drop; MGen.Drop
|
|
|
+ 594 ELSIF (SymTab.ClassOf(dt)
|
|
|
+ 595 = SymTab.ClArray)
|
|
|
+ 596 & (SymTab.ClassOf(
|
|
|
+ 597 SymTab.ArrayElem(dt))
|
|
|
+ 598 = SymTab.ClChar)
|
|
|
+ 599 & (SymTab.ClassOf(et)
|
|
|
+ 600 = SymTab.ClStr) THEN
|
|
|
+ 601 srcBytes :=
|
|
|
+ 602 MGen.StrLenOf(lxe) + 1;
|
|
|
+ 603 dstBytes :=
|
|
|
+ 604 SymTab.TypeSlots(dt) * 8;
|
|
|
+ 605 IF srcBytes > dstBytes THEN
|
|
|
+ 606 SemError(210);
|
|
|
+ 607 MGen.Drop; MGen.Drop
|
|
|
+ 608 ELSE
|
|
|
+ 609 MGen.PushBytes(srcBytes);
|
|
|
+ 610 MGen.CopyBlock
|
|
|
+ 611 END
|
|
|
+ 612 ELSIF ~SymTab.Assignable(et,
|
|
|
+ 613 dt) THEN
|
|
|
+ 614 SemError(210);
|
|
|
+ 615 MGen.Drop; MGen.Drop
|
|
|
+ 616 ELSE
|
|
|
+ 617 dstBytes :=
|
|
|
+ 618 SymTab.TypeSlots(dt) * 8;
|
|
|
+ 619 MGen.PushBytes(dstBytes);
|
|
|
+ 620 MGen.CopyBlock
|
|
|
+ 621 END
|
|
|
+ 622 ELSIF pushedFld THEN
|
|
|
+ 623 IF et = SymTab.InvalidType THEN
|
|
|
+ 624 MGen.Drop; MGen.Drop
|
|
|
+ 625 ELSIF (SymTab.TypeSlots(dt) > 1) THEN
|
|
|
+ 626 IF (SymTab.ClassOf(dt)
|
|
|
+ 627 = SymTab.ClArray)
|
|
|
+ 628 & (SymTab.ClassOf(
|
|
|
+ 629 SymTab.ArrayElem(dt))
|
|
|
+ 630 = SymTab.ClChar)
|
|
|
+ 631 & (SymTab.ClassOf(et)
|
|
|
+ 632 = SymTab.ClStr) THEN
|
|
|
+ 633 srcBytes :=
|
|
|
+ 634 MGen.StrLenOf(lxe) + 1;
|
|
|
+ 635 dstBytes :=
|
|
|
+ 636 SymTab.TypeSlots(dt) * 8;
|
|
|
+ 637 IF srcBytes > dstBytes THEN
|
|
|
+ 638 SemError(210);
|
|
|
+ 639 MGen.Drop; MGen.Drop
|
|
|
+ 640 ELSE
|
|
|
+ 641 MGen.PushBytes(srcBytes);
|
|
|
+ 642 MGen.CopyBlock
|
|
|
+ 643 END
|
|
|
+ 644 ELSIF ~SymTab.Assignable(et,
|
|
|
+ 645 dt) THEN
|
|
|
+ 646 SemError(210);
|
|
|
+ 647 MGen.Drop; MGen.Drop
|
|
|
+ 648 ELSE
|
|
|
+ 649 dstBytes :=
|
|
|
+ 650 SymTab.TypeSlots(dt) * 8;
|
|
|
+ 651 MGen.PushBytes(dstBytes);
|
|
|
+ 652 MGen.CopyBlock
|
|
|
+ 653 END
|
|
|
+ 654 ELSE
|
|
|
+ 655 IF ~SymTab.Assignable(et,
|
|
|
+ 656 dt) THEN
|
|
|
+ 657 SemError(210);
|
|
|
+ 658 MGen.Drop; MGen.Drop
|
|
|
+ 659 ELSE
|
|
|
+ 660 isR :=
|
|
|
+ 661 (SymTab.ClassOf(dt)
|
|
|
+ 662 = SymTab.ClReal);
|
|
|
+ 663 conv := isR
|
|
|
+ 664 & SymTab.IsIntFamily(et);
|
|
|
+ 665 IF conv THEN
|
|
|
+ 666 MGen.IntToReal
|
|
|
+ 667 END;
|
|
|
+ 668 IF (SymTab.ClassOf(dt)
|
|
|
+ 669 = SymTab.ClChar)
|
|
|
+ 670 OR (SymTab.ClassOf(dt)
|
|
|
+ 671 = SymTab.ClBool) THEN
|
|
|
+ 672 MGen.StoreByte
|
|
|
+ 673 ELSE MGen.StoreIndir0
|
|
|
+ 674 END
|
|
|
+ 675 END
|
|
|
+ 676 END
|
|
|
+ 677 ELSIF (dt # SymTab.InvalidType)
|
|
|
+ 678 & ~sfx
|
|
|
+ 679 & (SymTab.TypeSlots(dt) > 1) THEN
|
|
|
+ 680 IF ~SymTab.Assignable(et, dt) THEN
|
|
|
+ 681 SemError(210)
|
|
|
+ 682 ELSE SemError(230)
|
|
|
+ 683 END
|
|
|
+ 684 ELSIF ~SymTab.Assignable(et, dt) THEN
|
|
|
+ 685 SemError(210) END;
|
|
|
+ 686 IF dk = SymTab.KindImport THEN
|
|
|
+ 687 SemError(230)
|
|
|
+ 688 END;
|
|
|
+ 689 isR := (dt # SymTab.InvalidType)
|
|
|
+ 690 & ~pushedDst
|
|
|
+ 691 & ~pushedFld
|
|
|
+ 692 & (SymTab.ClassOf(dt)
|
|
|
+ 693 = SymTab.ClReal);
|
|
|
+ 694 conv := isR
|
|
|
+ 695 & SymTab.IsIntFamily(et);
|
|
|
+ 696 IF pushedDst THEN
|
|
|
+ 697 ELSIF pushedFld THEN
|
|
|
+ 698 ELSIF (dt # SymTab.InvalidType)
|
|
|
+ 699 & sfx THEN
|
|
|
+ 700 IF conv THEN
|
|
|
+ 701 MGen.IntToReal
|
|
|
+ 702 END;
|
|
|
+ 703 IF (SymTab.ClassOf(dt)
|
|
|
+ 704 = SymTab.ClChar)
|
|
|
+ 705 OR (SymTab.ClassOf(dt)
|
|
|
+ 706 = SymTab.ClBool) THEN
|
|
|
+ 707 MGen.StoreByte
|
|
|
+ 708 ELSE MGen.StoreIndir0
|
|
|
+ 709 END
|
|
|
+ 710 ELSIF storable & ~sfx THEN
|
|
|
+ 711 IF (dt # SymTab.InvalidType)
|
|
|
+ 712 & (SymTab.TypeSlots(dt)
|
|
|
+ 713 > 1) THEN
|
|
|
+ 714 MGen.Drop
|
|
|
+ 715 ELSE
|
|
|
+ 716 IF conv THEN
|
|
|
+ 717 MGen.IntToReal
|
|
|
+ 718 END;
|
|
|
+ 719 MGen.StoreFinish(bn)
|
|
|
+ 720 END
|
|
|
+ 721 ELSE MGen.Drop
|
|
|
+ 722 END; .)
|
|
|
+ 723 | CallTail<bn, sfx, FALSE, okC, FALSE>
|
|
|
+ 724 | (. MGen.ActBegin(bn);
|
|
|
+ 725 IF MGen.ActEnd(bn, FALSE, FALSE) # 0 THEN
|
|
|
+ 726 SemError(233)
|
|
|
+ 727 END; .) ) .
|
|
|
+ 728 CallTail <pn: SymTab.Name; sfx: BOOLEAN; inExpr: BOOLEAN;
|
|
|
+ 729 VAR ok: BOOLEAN; hasDead: BOOLEAN>
|
|
|
+ 730 (. VAR t: SymTab.TypeIndex;
|
|
|
+ 731 lx: MGen.LitStr;
|
|
|
+ 732 v: BOOLEAN;
|
|
|
+ 733 vn: SymTab.Name; .)
|
|
|
+ 734 = "(" (. ok := FALSE;
|
|
|
+ 735 IF hasDead THEN MGen.Drop END;
|
|
|
+ 736 MGen.ActBegin(pn); .)
|
|
|
+ 737 [ Expr<t, lx, v, vn> (. IF MGen.ActValue(t, v, vn) # 0 THEN
|
|
|
+ 738 SemError(233)
|
|
|
+ 739 END; .)
|
|
|
+ 740 { "," Expr<t, lx, v, vn> (. IF MGen.ActValue(t, v, vn) # 0 THEN
|
|
|
+ 741 SemError(233)
|
|
|
+ 742 END; .) } ]
|
|
|
+ 743 ")" (. IF MGen.ActEnd(pn, sfx, inExpr) # 0
|
|
|
+ 744 THEN SemError(233)
|
|
|
+ 745 ELSE ok := TRUE
|
|
|
+ 746 END; .) .
|
|
|
+ 747 IfStat (. VAR t: SymTab.TypeIndex;
|
|
|
+ 748 lxC: MGen.LitStr;
|
|
|
+ 749 vC: BOOLEAN;
|
|
|
+ 750 vnC: SymTab.Name;
|
|
|
+ 751 elseL, endL: INTEGER;
|
|
|
+ 752 hasElse: BOOLEAN; .)
|
|
|
+ 753 = "IF"
|
|
|
+ 754 Expr<t, lxC, vC, vnC> (. IF ~SymTab.BoolCheck(t) THEN
|
|
|
+ 755 SemError(214) END;
|
|
|
+ 756 elseL := MGen.NewLabel();
|
|
|
+ 757 endL := MGen.NewLabel();
|
|
|
+ 758 MGen.Jz(elseL);
|
|
|
+ 759 hasElse := FALSE; .)
|
|
|
+ 760 "THEN"
|
|
|
+ 761 StatSeq
|
|
|
+ 762 { "ELSIF" (. MGen.Jmp(endL);
|
|
|
+ 763 MGen.DefLabel(elseL); .)
|
|
|
+ 764 Expr<t, lxC, vC, vnC> (. IF ~SymTab.BoolCheck(t) THEN
|
|
|
+ 765 SemError(214) END;
|
|
|
+ 766 elseL := MGen.NewLabel();
|
|
|
+ 767 MGen.Jz(elseL); .)
|
|
|
+ 768 "THEN"
|
|
|
+ 769 StatSeq }
|
|
|
+ 770 [ "ELSE" (. MGen.Jmp(endL);
|
|
|
+ 771 MGen.DefLabel(elseL);
|
|
|
+ 772 hasElse := TRUE; .)
|
|
|
+ 773 StatSeq ]
|
|
|
+ 774 "END" (. IF ~hasElse THEN
|
|
|
+ 775 MGen.DefLabel(elseL)
|
|
|
+ 776 END;
|
|
|
+ 777 MGen.DefLabel(endL); .) .
|
|
|
+ 778 CaseStat (. VAR st: SymTab.TypeIndex;
|
|
|
+ 779 lxS: MGen.LitStr;
|
|
|
+ 780 vS: BOOLEAN;
|
|
|
+ 781 vnS: SymTab.Name;
|
|
|
+ 782 tmp, endL: INTEGER; .)
|
|
|
+ 783 = "CASE"
|
|
|
+ 784 Expr<st, lxS, vS, vnS> (. tmp := MGen.TempGlobal();
|
|
|
+ 785 MGen.StoreTemp(tmp);
|
|
|
+ 786 endL := MGen.NewLabel(); .)
|
|
|
+ 787 "OF"
|
|
|
+ 788 Case<st, tmp, endL> { "|"
|
|
|
+ 789 Case<st, tmp, endL> }
|
|
|
+ 790 [ "ELSE"
|
|
|
+ 791 StatSeq ]
|
|
|
+ 792 "END" (. MGen.DefLabel(endL); .) .
|
|
|
+ 793 Case <sel: SymTab.TypeIndex; tmp: INTEGER; endL: INTEGER>
|
|
|
+ 794 (. VAR lB, lN: INTEGER; .)
|
|
|
+ 795 = [ LabelList<sel, tmp, lB, lN> ":" (. MGen.DefLabel(lB); .)
|
|
|
+ 796 StatSeq (. MGen.Jmp(endL);
|
|
|
+ 797 MGen.DefLabel(lN); .) ] .
|
|
|
+ 798 LabelList <sel: SymTab.TypeIndex; tmp: INTEGER;
|
|
|
+ 799 VAR lB: INTEGER; VAR lN: INTEGER>
|
|
|
+ 800 = (. lB := MGen.NewLabel();
|
|
|
+ 801 lN := MGen.NewLabel(); .)
|
|
|
+ 802 Labels<sel, tmp, lB> { ","
|
|
|
+ 803 Labels<sel, tmp, lB> }
|
|
|
+ 804 (. MGen.Jmp(lN); .) .
|
|
|
+ 805 Labels <sel: SymTab.TypeIndex; tmp: INTEGER; bodyL: INTEGER>
|
|
|
+ 806 (. VAR t, t2: SymTab.TypeIndex;
|
|
|
+ 807 lx1, lx2: MGen.LitStr;
|
|
|
+ 808 v1, v2: BOOLEAN;
|
|
|
+ 809 vn1, vn2: SymTab.Name;
|
|
|
+ 810 ta, tb, chunk: INTEGER;
|
|
|
+ 811 r, hasRange: BOOLEAN; .)
|
|
|
+ 812 = ConstExpr<t, lx1> (. IF ~SymTab.EqCheck(t, sel) THEN
|
|
|
+ 813 SemError(213) END;
|
|
|
+ 814 r := (SymTab.ClassOf(sel)
|
|
|
+ 815 = SymTab.ClReal)
|
|
|
+ 816 & (SymTab.ClassOf(t)
|
|
|
+ 817 = SymTab.ClReal);
|
|
|
+ 818 ta := MGen.TempGlobal();
|
|
|
+ 819 MGen.StoreTemp(ta);
|
|
|
+ 820 hasRange := FALSE; .)
|
|
|
+ 821 [ ".."
|
|
|
+ 822 ConstExpr<t2, lx2> (. IF ~SymTab.EqCheck(t2, sel) THEN
|
|
|
+ 823 SemError(213) END;
|
|
|
+ 824 tb := MGen.TempGlobal();
|
|
|
+ 825 MGen.StoreTemp(tb);
|
|
|
+ 826 hasRange := TRUE; .) ]
|
|
|
+ 827 (. IF hasRange THEN
|
|
|
+ 828 MGen.LoadTemp(tmp);
|
|
|
+ 829 MGen.LoadTemp(ta);
|
|
|
+ 830 IF r THEN MGen.RealGe
|
|
|
+ 831 ELSE MGen.IGe END;
|
|
|
+ 832 MGen.LoadTemp(tmp);
|
|
|
+ 833 MGen.LoadTemp(tb);
|
|
|
+ 834 IF r THEN MGen.RealLe
|
|
|
+ 835 ELSE MGen.ILe END;
|
|
|
+ 836 MGen.And
|
|
|
+ 837 ELSE
|
|
|
+ 838 MGen.LoadTemp(tmp);
|
|
|
+ 839 MGen.LoadTemp(ta);
|
|
|
+ 840 IF r THEN MGen.RealEq
|
|
|
+ 841 ELSE MGen.Eq END
|
|
|
+ 842 END;
|
|
|
+ 843 chunk := MGen.NewLabel();
|
|
|
+ 844 MGen.Jz(chunk);
|
|
|
+ 845 MGen.Jmp(bodyL);
|
|
|
+ 846 MGen.DefLabel(chunk); .) .
|
|
|
+ 847 WhileStat (. VAR t: SymTab.TypeIndex;
|
|
|
+ 848 lxC: MGen.LitStr;
|
|
|
+ 849 vC: BOOLEAN;
|
|
|
+ 850 vnC: SymTab.Name;
|
|
|
+ 851 topL, endL: INTEGER; .)
|
|
|
+ 852 = "WHILE" (. topL := MGen.NewLabel();
|
|
|
+ 853 endL := MGen.NewLabel();
|
|
|
+ 854 MGen.DefLabel(topL); .)
|
|
|
+ 855 Expr<t, lxC, vC, vnC> (. IF ~SymTab.BoolCheck(t) THEN
|
|
|
+ 856 SemError(214) END;
|
|
|
+ 857 MGen.Jz(endL); .)
|
|
|
+ 858 "DO"
|
|
|
+ 859 StatSeq
|
|
|
+ 860 "END" (. MGen.Jmp(topL);
|
|
|
+ 861 MGen.DefLabel(endL); .) .
|
|
|
+ 862 RepeatStat (. VAR t: SymTab.TypeIndex;
|
|
|
+ 863 lxC: MGen.LitStr;
|
|
|
+ 864 vC: BOOLEAN;
|
|
|
+ 865 vnC: SymTab.Name;
|
|
|
+ 866 topL: INTEGER; .)
|
|
|
+ 867 = "REPEAT" (. topL := MGen.NewLabel();
|
|
|
+ 868 MGen.DefLabel(topL); .)
|
|
|
+ 869 StatSeq
|
|
|
+ 870 "UNTIL"
|
|
|
+ 871 Expr<t, lxC, vC, vnC> (. IF ~SymTab.BoolCheck(t) THEN
|
|
|
+ 872 SemError(214) END;
|
|
|
+ 873 MGen.Jz(topL); .) .
|
|
|
+ 874 LoopStat (. VAR topL, exitL: INTEGER; .)
|
|
|
+ 875 = "LOOP" (. topL := MGen.NewLabel();
|
|
|
+ 876 exitL := MGen.NewLabel();
|
|
|
+ 877 MGen.DefLabel(topL);
|
|
|
+ 878 MGen.PushLoop(exitL); .)
|
|
|
+ 879 StatSeq
|
|
|
+ 880 "END" (. MGen.Jmp(topL);
|
|
|
+ 881 MGen.DefLabel(exitL);
|
|
|
+ 882 MGen.PopLoop; .) .
|
|
|
+ 883 ForStat (. VAR n, lv: SymTab.Name;
|
|
|
+ 884 fk: INTEGER;
|
|
|
+ 885 lo, hi: SymTab.TypeIndex;
|
|
|
+ 886 lxLo, lxHi: MGen.LitStr;
|
|
|
+ 887 vLo, vHi: BOOLEAN;
|
|
|
+ 888 vnLo, vnHi: SymTab.Name;
|
|
|
+ 889 byV, ht: INTEGER;
|
|
|
+ 890 lTop, lChk, lEnd: INTEGER;
|
|
|
+ 891 neg, storable: BOOLEAN; .)
|
|
|
+ 892 = "FOR"
|
|
|
+ 893 GetIdent<n> (. IF ~SymTab.Lookup(n) THEN
|
|
|
+ 894 SemError(201);
|
|
|
+ 895 fk := -1
|
|
|
+ 896 ELSIF (SymTab.SymKind(n) #
|
|
|
+ 897 SymTab.KindVar)
|
|
|
+ 898 & (SymTab.SymKind(n) #
|
|
|
+ 899 SymTab.KindParam)
|
|
|
+ 900 & (SymTab.SymKind(n) #
|
|
|
+ 901 SymTab.KindVarPar)
|
|
|
+ 902 & (SymTab.SymKind(n) #
|
|
|
+ 903 SymTab.KindField) THEN
|
|
|
+ 904 SemError(220);
|
|
|
+ 905 fk := -1
|
|
|
+ 906 ELSIF (SymTab.SymType(n) #
|
|
|
+ 907 SymTab.InvalidType)
|
|
|
+ 908 & ~SymTab.IsIntFamily(
|
|
|
+ 909 SymTab.SymType(n)) THEN
|
|
|
+ 910 SemError(220);
|
|
|
+ 911 fk := -1
|
|
|
+ 912 ELSE
|
|
|
+ 913 fk := SymTab.SymKind(n)
|
|
|
+ 914 END;
|
|
|
+ 915 MGen.CopyName(n, lv);
|
|
|
+ 916 storable := (fk = SymTab.KindVar)
|
|
|
+ 917 OR (fk = SymTab.KindParam)
|
|
|
+ 918 OR (fk = SymTab.KindVarPar);
|
|
|
+ 919 IF storable THEN
|
|
|
+ 920 MGen.StoreSetup(lv)
|
|
|
+ 921 END; .)
|
|
|
+ 922 ":="
|
|
|
+ 923 Expr<lo, lxLo, vLo, vnLo> (. IF (lo # SymTab.InvalidType)
|
|
|
+ 924 & ~SymTab.IsIntFamily(lo) THEN
|
|
|
+ 925 SemError(220) END;
|
|
|
+ 926 IF storable THEN
|
|
|
+ 927 MGen.StoreFinish(lv)
|
|
|
+ 928 ELSE MGen.Drop
|
|
|
+ 929 END; .)
|
|
|
+ 930 "TO"
|
|
|
+ 931 Expr<hi, lxHi, vHi, vnHi> (. IF (hi # SymTab.InvalidType)
|
|
|
+ 932 & ~SymTab.IsIntFamily(hi) THEN
|
|
|
+ 933 SemError(220) END;
|
|
|
+ 934 ht := MGen.TempGlobal();
|
|
|
+ 935 MGen.StoreTemp(ht);
|
|
|
+ 936 byV := 1; neg := FALSE; .)
|
|
|
+ 937 [ "BY"
|
|
|
+ 938 ByLit<byV> (. neg := byV < 0; .) ]
|
|
|
+ 939 "DO" (. lTop := MGen.NewLabel();
|
|
|
+ 940 lChk := MGen.NewLabel();
|
|
|
+ 941 lEnd := MGen.NewLabel();
|
|
|
+ 942 MGen.Jmp(lChk);
|
|
|
+ 943 MGen.DefLabel(lTop); .)
|
|
|
+ 944 StatSeq
|
|
|
+ 945 "END" (. MGen.PushVar(lv);
|
|
|
+ 946 MGen.PushInt(byV);
|
|
|
+ 947 MGen.Add;
|
|
|
+ 948 IF storable THEN
|
|
|
+ 949 MGen.StoreFinish(lv)
|
|
|
+ 950 ELSE MGen.Drop
|
|
|
+ 951 END;
|
|
|
+ 952 MGen.DefLabel(lChk);
|
|
|
+ 953 MGen.PushVar(lv);
|
|
|
+ 954 MGen.LoadTemp(ht);
|
|
|
+ 955 IF neg THEN MGen.IGe
|
|
|
+ 956 ELSE MGen.ILe END;
|
|
|
+ 957 MGen.Jz(lEnd);
|
|
|
+ 958 MGen.Jmp(lTop);
|
|
|
+ 959 MGen.DefLabel(lEnd); .) .
|
|
|
+ 960 ByLit <VAR v: INTEGER> (. VAR s: ARRAY [0 .. 255] OF CHAR; .)
|
|
|
+ 961 = integer (. LexString(s);
|
|
|
+ 962 IF ~MGen.ParseInt(s, v) THEN
|
|
|
+ 963 v := 1
|
|
|
+ 964 END; .)
|
|
|
+ 965 | "-" integer (. LexString(s);
|
|
|
+ 966 IF MGen.ParseInt(s, v) THEN
|
|
|
+ 967 v := -v
|
|
|
+ 968 ELSE v := -1
|
|
|
+ 969 END; .) .
|
|
|
+ 970 WithStat (. VAR dt: SymTab.TypeIndex;
|
|
|
+ 971 dk: INTEGER;
|
|
|
+ 972 bnW: SymTab.Name;
|
|
|
+ 973 lxW: MGen.LitStr;
|
|
|
+ 974 sfxW: BOOLEAN;
|
|
|
+ 975 pushed: BOOLEAN; .)
|
|
|
+ 976 = "WITH"
|
|
|
+ 977 DesignHead<dt, dk, bnW, FALSE, lxW>
|
|
|
+ 978 DesignTail<dt, dk, bnW, FALSE, lxW, sfxW>
|
|
|
+ 979 (. pushed := FALSE;
|
|
|
+ 980 IF dt = SymTab.InvalidType THEN
|
|
|
+ 981 IF sfxW THEN MGen.Drop END
|
|
|
+ 982 ELSIF SymTab.ClassOf(dt)
|
|
|
+ 983 # SymTab.ClRecord THEN
|
|
|
+ 984 SemError(215);
|
|
|
+ 985 IF sfxW THEN MGen.Drop END
|
|
|
+ 986 ELSE
|
|
|
+ 987 IF ~sfxW THEN
|
|
|
+ 988 IF (dk
|
|
|
+ 989 = SymTab.KindVar)
|
|
|
+ 990 OR (dk
|
|
|
+ 991 = SymTab.KindParam)
|
|
|
+ 992 OR (dk
|
|
|
+ 993 = SymTab.KindVarPar) THEN
|
|
|
+ 994 MGen.PushAddr(bnW)
|
|
|
+ 995 ELSIF dk
|
|
|
+ 996 = SymTab.KindField THEN
|
|
|
+ 997 MGen.WithAddr(bnW)
|
|
|
+ 998 ELSE MGen.PushInt(0)
|
|
|
+ 999 END
|
|
|
+ 1000 END;
|
|
|
+ 1001 MGen.WithEnter(dt);
|
|
|
+ 1002 pushed :=
|
|
|
+ 1003 SymTab.PushRecord(dt);
|
|
|
+ 1004 IF ~pushed THEN
|
|
|
+ 1005 SemError(215)
|
|
|
+ 1006 END
|
|
|
+ 1007 END; .)
|
|
|
+ 1008 "DO"
|
|
|
+ 1009 StatSeq
|
|
|
+ 1010 "END" (. IF pushed THEN
|
|
|
+ 1011 SymTab.PopScope;
|
|
|
+ 1012 MGen.WithExit
|
|
|
+ 1013 END; .) .
|
|
|
+ 1014 ReturnStat (. VAR t: SymTab.TypeIndex;
|
|
|
+ 1015 lx: MGen.LitStr;
|
|
|
+ 1016 v: BOOLEAN;
|
|
|
+ 1017 vn: SymTab.Name;
|
|
|
+ 1018 hasE, doRet, conv: BOOLEAN; .)
|
|
|
+ 1019 = "RETURN" (. hasE := FALSE; .)
|
|
|
+ 1020 [ Expr<t, lx, v, vn> (. hasE := TRUE;
|
|
|
+ 1021 doRet := FALSE;
|
|
|
+ 1022 IF ~SymTab.InProc() THEN
|
|
|
+ 1023 SemError(232)
|
|
|
+ 1024 ELSIF ~SymTab.InFunction() THEN
|
|
|
+ 1025 SemError(232)
|
|
|
+ 1026 ELSIF ~SymTab.Assignable(
|
|
|
+ 1027 t, SymTab.CurRet()) THEN
|
|
|
+ 1028 SemError(232)
|
|
|
+ 1029 ELSE doRet := TRUE
|
|
|
+ 1030 END;
|
|
|
+ 1031 conv := doRet
|
|
|
+ 1032 & SymTab.IsIntFamily(t)
|
|
|
+ 1033 & (SymTab.ClassOf(
|
|
|
+ 1034 SymTab.CurRet())
|
|
|
+ 1035 = SymTab.ClReal);
|
|
|
+ 1036 IF doRet THEN
|
|
|
+ 1037 IF conv THEN
|
|
|
+ 1038 MGen.IntToReal
|
|
|
+ 1039 END;
|
|
|
+ 1040 MGen.Leave(
|
|
|
+ 1041 SymTab.CurNPar(), TRUE)
|
|
|
+ 1042 ELSE MGen.Drop
|
|
|
+ 1043 END; .) ]
|
|
|
+ 1044 (. IF ~hasE THEN
|
|
|
+ 1045 IF ~SymTab.InProc() THEN
|
|
|
+ 1046 SemError(232)
|
|
|
+ 1047 ELSIF SymTab.InFunction() THEN
|
|
|
+ 1048 SemError(232)
|
|
|
+ 1049 ELSE MGen.Leave(
|
|
|
+ 1050 SymTab.CurNPar(), FALSE)
|
|
|
+ 1051 END
|
|
|
+ 1052 END; .) .
|
|
|
+ 1053 NewStat (. VAR dt: SymTab.TypeIndex;
|
|
|
+ 1054 dk: INTEGER;
|
|
|
+ 1055 bnN: SymTab.Name;
|
|
|
+ 1056 lxN: MGen.LitStr;
|
|
|
+ 1057 sfxN: BOOLEAN;
|
|
|
+ 1058 baseT: SymTab.TypeIndex;
|
|
|
+ 1059 slN: CARDINAL; .)
|
|
|
+ 1060 = "NEW"
|
|
|
+ 1061 "(" DesignHead<dt, dk, bnN, FALSE, lxN>
|
|
|
+ 1062 DesignTail<dt, dk, bnN, FALSE, lxN, sfxN>
|
|
|
+ 1063 ")" (. IF dt = SymTab.InvalidType THEN
|
|
|
+ 1064 IF sfxN THEN MGen.Drop END
|
|
|
+ 1065 ELSIF SymTab.ClassOf(dt)
|
|
|
+ 1066 # SymTab.ClPtr THEN
|
|
|
+ 1067 SemError(219);
|
|
|
+ 1068 IF sfxN THEN MGen.Drop END
|
|
|
+ 1069 ELSE
|
|
|
+ 1070 baseT := SymTab.PtrBase(dt);
|
|
|
+ 1071 slN := SymTab.TypeSlots(baseT);
|
|
|
+ 1072 IF slN = 0 THEN
|
|
|
+ 1073 SemError(230);
|
|
|
+ 1074 slN := 1
|
|
|
+ 1075 END;
|
|
|
+ 1076 IF ~sfxN THEN
|
|
|
+ 1077 IF (dk = SymTab.KindVar)
|
|
|
+ 1078 OR (dk
|
|
|
+ 1079 = SymTab.KindParam)
|
|
|
+ 1080 OR (dk
|
|
|
+ 1081 = SymTab.KindVarPar) THEN
|
|
|
+ 1082 MGen.PushAddr(bnN)
|
|
|
+ 1083 ELSIF dk
|
|
|
+ 1084 = SymTab.KindField THEN
|
|
|
+ 1085 MGen.WithAddr(bnN)
|
|
|
+ 1086 ELSE MGen.PushInt(0)
|
|
|
+ 1087 END
|
|
|
+ 1088 END;
|
|
|
+ 1089 MGen.PushBytes(slN * 8);
|
|
|
+ 1090 MGen.AllocOp
|
|
|
+ 1091 END; .) .
|
|
|
+ 1092 DispStat (. VAR dt: SymTab.TypeIndex;
|
|
|
+ 1093 dk: INTEGER;
|
|
|
+ 1094 bnD: SymTab.Name;
|
|
|
+ 1095 lxD: MGen.LitStr;
|
|
|
+ 1096 sfxD: BOOLEAN;
|
|
|
+ 1097 baseT: SymTab.TypeIndex;
|
|
|
+ 1098 slD: CARDINAL; .)
|
|
|
+ 1099 = "DISPOSE"
|
|
|
+ 1100 "(" DesignHead<dt, dk, bnD, FALSE, lxD>
|
|
|
+ 1101 DesignTail<dt, dk, bnD, FALSE, lxD, sfxD>
|
|
|
+ 1102 ")" (. IF dt = SymTab.InvalidType THEN
|
|
|
+ 1103 IF sfxD THEN MGen.Drop END
|
|
|
+ 1104 ELSIF SymTab.ClassOf(dt)
|
|
|
+ 1105 # SymTab.ClPtr THEN
|
|
|
+ 1106 SemError(219);
|
|
|
+ 1107 IF sfxD THEN MGen.Drop END
|
|
|
+ 1108 ELSE
|
|
|
+ 1109 baseT := SymTab.PtrBase(dt);
|
|
|
+ 1110 slD := SymTab.TypeSlots(baseT);
|
|
|
+ 1111 IF slD = 0 THEN
|
|
|
+ 1112 SemError(230);
|
|
|
+ 1113 slD := 1
|
|
|
+ 1114 END;
|
|
|
+ 1115 IF ~sfxD THEN
|
|
|
+ 1116 IF (dk = SymTab.KindVar)
|
|
|
+ 1117 OR (dk
|
|
|
+ 1118 = SymTab.KindParam)
|
|
|
+ 1119 OR (dk
|
|
|
+ 1120 = SymTab.KindVarPar) THEN
|
|
|
+ 1121 MGen.PushAddr(bnD)
|
|
|
+ 1122 ELSIF dk
|
|
|
+ 1123 = SymTab.KindField THEN
|
|
|
+ 1124 MGen.WithAddr(bnD)
|
|
|
+ 1125 ELSE MGen.PushInt(0)
|
|
|
+ 1126 END
|
|
|
+ 1127 END;
|
|
|
+ 1128 MGen.PushBytes(slD * 8);
|
|
|
+ 1129 MGen.DeallocOp
|
|
|
+ 1130 END; .) .
|
|
|
+ 1131 WriteIntStat (. VAR t: SymTab.TypeIndex;
|
|
|
+ 1132 lx: MGen.LitStr;
|
|
|
+ 1133 v: BOOLEAN;
|
|
|
+ 1134 vn: SymTab.Name; .)
|
|
|
+ 1135 = "WriteInt"
|
|
|
+ 1136 "(" Expr<t, lx, v, vn> ")" (. IF t = SymTab.InvalidType THEN
|
|
|
+ 1137 MGen.Drop
|
|
|
+ 1138 ELSIF ~SymTab.IsIntFamily(t) THEN
|
|
|
+ 1139 SemError(210);
|
|
|
+ 1140 MGen.Drop
|
|
|
+ 1141 ELSE
|
|
|
+ 1142 MGen.CallPrint
|
|
|
+ 1143 END; .) .
|
|
|
+ 1144 WriteStrStat (. VAR t: SymTab.TypeIndex;
|
|
|
+ 1145 lx: MGen.LitStr;
|
|
|
+ 1146 v: BOOLEAN;
|
|
|
+ 1147 vn: SymTab.Name; .)
|
|
|
+ 1148 = "WriteString"
|
|
|
+ 1149 "(" Expr<t, lx, v, vn> ")" (. IF t = SymTab.InvalidType THEN
|
|
|
+ 1150 MGen.Drop
|
|
|
+ 1151 ELSIF (SymTab.ClassOf(t)
|
|
|
+ 1152 = SymTab.ClStr) THEN
|
|
|
+ 1153 MGen.PushInt(1);
|
|
|
+ 1154 MGen.SysCall
|
|
|
+ 1155 ELSIF (SymTab.ClassOf(t)
|
|
|
+ 1156 = SymTab.ClArray)
|
|
|
+ 1157 & (SymTab.ClassOf(
|
|
|
+ 1158 SymTab.ArrayElem(t))
|
|
|
+ 1159 = SymTab.ClChar) THEN
|
|
|
+ 1160 MGen.PushInt(1);
|
|
|
+ 1161 MGen.SysCall
|
|
|
+ 1162 ELSE
|
|
|
+ 1163 SemError(210);
|
|
|
+ 1164 MGen.Drop
|
|
|
+ 1165 END; .) .
|
|
|
+ 1166
|
|
|
+ 1167 (* Expressions: Designator without ActualParameters (calls use
|
|
|
+ 1168 CallTail). Each expression synthesizes its SymTab type in t,
|
|
|
+ 1169 the source text in lx for single literals ("" otherwise), and
|
|
|
+ 1170 whether it is a plain variable (v/vn) for VAR actuals.
|
|
|
+ 1171 Values travel on the MC64 stack. *)
|
|
|
+ 1172 DesignHead <VAR t: SymTab.TypeIndex; VAR k: INTEGER;
|
|
|
+ 1173 VAR bn: SymTab.Name; doLoad: BOOLEAN; VAR lx: MGen.LitStr>
|
|
|
+ 1174 (. VAR n: SymTab.Name;
|
|
|
+ 1175 cls: INTEGER; .)
|
|
|
+ 1176 = GetIdent<n> (. MGen.CopyName(n, bn);
|
|
|
+ 1177 lx[0] := 0C;
|
|
|
+ 1178 IF ~SymTab.Lookup(n) THEN
|
|
|
+ 1179 SemError(201);
|
|
|
+ 1180 t := SymTab.InvalidType; k := -1;
|
|
|
+ 1181 IF doLoad THEN
|
|
|
+ 1182 MGen.PushInt(0)
|
|
|
+ 1183 END
|
|
|
+ 1184 ELSE
|
|
|
+ 1185 t := SymTab.SymType(n);
|
|
|
+ 1186 k := SymTab.SymKind(n);
|
|
|
+ 1187 IF k = SymTab.KindConst THEN
|
|
|
+ 1188 IF SymTab.Equal(n, "TRUE") THEN
|
|
|
+ 1189 t := SymTab.BoolType();
|
|
|
+ 1190 MGen.CopyName("TRUE", lx);
|
|
|
+ 1191 IF doLoad THEN
|
|
|
+ 1192 MGen.PushInt(1)
|
|
|
+ 1193 END
|
|
|
+ 1194 ELSIF SymTab.Equal(n,
|
|
|
+ 1195 "FALSE") THEN
|
|
|
+ 1196 t := SymTab.BoolType();
|
|
|
+ 1197 MGen.CopyName("FALSE", lx);
|
|
|
+ 1198 IF doLoad THEN
|
|
|
+ 1199 MGen.PushInt(0)
|
|
|
+ 1200 END
|
|
|
+ 1201 ELSE
|
|
|
+ 1202 cls :=
|
|
|
+ 1203 SymTab.ClassOf(t);
|
|
|
+ 1204 IF (t #
|
|
|
+ 1205 SymTab.InvalidType)
|
|
|
+ 1206 & (cls # SymTab.ClStr)
|
|
|
+ 1207 & ((cls = SymTab.ClInt)
|
|
|
+ 1208 OR (cls = SymTab.ClReal)
|
|
|
+ 1209 OR (cls = SymTab.ClBool)
|
|
|
+ 1210 OR (cls = SymTab.ClChar)
|
|
|
+ 1211 OR (cls
|
|
|
+ 1212 = SymTab.ClEnum)) THEN
|
|
|
+ 1213 IF doLoad THEN
|
|
|
+ 1214 MGen.LoadVar(n)
|
|
|
+ 1215 END
|
|
|
+ 1216 ELSIF doLoad THEN
|
|
|
+ 1217 MGen.PushInt(0)
|
|
|
+ 1218 END
|
|
|
+ 1219 END
|
|
|
+ 1220 ELSIF (k = SymTab.KindVar)
|
|
|
+ 1221 OR (k = SymTab.KindParam)
|
|
|
+ 1222 OR (k
|
|
|
+ 1223 = SymTab.KindVarPar) THEN
|
|
|
+ 1224 cls := SymTab.ClassOf(t);
|
|
|
+ 1225 IF (cls = SymTab.ClInt)
|
|
|
+ 1226 OR (cls = SymTab.ClReal)
|
|
|
+ 1227 OR (cls = SymTab.ClBool)
|
|
|
+ 1228 OR (cls = SymTab.ClChar)
|
|
|
+ 1229 OR (cls
|
|
|
+ 1230 = SymTab.ClEnum)
|
|
|
+ 1231 OR (cls
|
|
|
+ 1232 = SymTab.ClSet)
|
|
|
+ 1233 OR (cls
|
|
|
+ 1234 = SymTab.ClPtr) THEN
|
|
|
+ 1235 IF doLoad THEN
|
|
|
+ 1236 MGen.PushVar(n)
|
|
|
+ 1237 END
|
|
|
+ 1238 ELSIF (cls
|
|
|
+ 1239 = SymTab.ClArray)
|
|
|
+ 1240 OR (cls
|
|
|
+ 1241 = SymTab.ClRecord) THEN
|
|
|
+ 1242 IF doLoad THEN
|
|
|
+ 1243 MGen.PushAddr(n)
|
|
|
+ 1244 END
|
|
|
+ 1245 ELSIF t
|
|
|
+ 1246 = SymTab.InvalidType THEN
|
|
|
+ 1247 IF doLoad THEN
|
|
|
+ 1248 MGen.PushInt(0)
|
|
|
+ 1249 END
|
|
|
+ 1250 ELSE SemError(230);
|
|
|
+ 1251 IF doLoad THEN
|
|
|
+ 1252 MGen.PushInt(0)
|
|
|
+ 1253 END
|
|
|
+ 1254 END
|
|
|
+ 1255 ELSE
|
|
|
+ 1256 IF doLoad THEN
|
|
|
+ 1257 IF k = SymTab.KindField THEN
|
|
|
+ 1258 MGen.WithAddr(n);
|
|
|
+ 1259 cls := SymTab.ClassOf(t);
|
|
|
+ 1260 IF (t
|
|
|
+ 1261 = SymTab.InvalidType)
|
|
|
+ 1262 OR (cls
|
|
|
+ 1263 = SymTab.ClArray)
|
|
|
+ 1264 OR (cls
|
|
|
+ 1265 = SymTab.ClRecord) THEN
|
|
|
+ 1266 ELSE
|
|
|
+ 1267 IF (cls
|
|
|
+ 1268 = SymTab.ClChar)
|
|
|
+ 1269 OR (cls
|
|
|
+ 1270 = SymTab.ClBool) THEN
|
|
|
+ 1271 MGen.LoadByte
|
|
|
+ 1272 ELSE MGen.LoadIndir
|
|
|
+ 1273 END
|
|
|
+ 1274 END
|
|
|
+ 1275 ELSE MGen.PushInt(0)
|
|
|
+ 1276 END
|
|
|
+ 1277 END;
|
|
|
+ 1278 IF k = SymTab.KindField THEN
|
|
|
+ 1279 ELSIF k
|
|
|
+ 1280 = SymTab.KindImport THEN
|
|
|
+ 1281 SemError(230)
|
|
|
+ 1282 END
|
|
|
+ 1283 END
|
|
|
+ 1284 END; .) .
|
|
|
+ 1285 DesignTail <VAR t: SymTab.TypeIndex; VAR k: INTEGER;
|
|
|
+ 1286 VAR bn: SymTab.Name; doLoad: BOOLEAN; VAR lx: MGen.LitStr;
|
|
|
+ 1287 VAR sfx: BOOLEAN>
|
|
|
+ 1288 (. VAR m: SymTab.Name;
|
|
|
+ 1289 it: SymTab.TypeIndex;
|
|
|
+ 1290 lxI: MGen.LitStr;
|
|
|
+ 1291 vI: BOOLEAN;
|
|
|
+ 1292 vnI: SymTab.Name;
|
|
|
+ 1293 loA: INTEGER;
|
|
|
+ 1294 elemT: SymTab.TypeIndex;
|
|
|
+ 1295 esl, ebytes: CARDINAL;
|
|
|
+ 1296 firstT: BOOLEAN;
|
|
|
+ 1297 clsI: INTEGER; .)
|
|
|
+ 1298 = (. sfx := FALSE; .)
|
|
|
+ 1299 { "." (. firstT := ~sfx;
|
|
|
+ 1300 sfx := TRUE; lx[0] := 0C;
|
|
|
+ 1301 IF ~doLoad & firstT THEN
|
|
|
+ 1302 IF (k = SymTab.KindVar)
|
|
|
+ 1303 OR (k = SymTab.KindParam)
|
|
|
+ 1304 OR (k
|
|
|
+ 1305 = SymTab.KindVarPar) THEN
|
|
|
+ 1306 MGen.PushAddr(bn)
|
|
|
+ 1307 ELSIF k
|
|
|
+ 1308 = SymTab.KindField THEN
|
|
|
+ 1309 MGen.WithAddr(bn)
|
|
|
+ 1310 ELSE MGen.PushInt(0)
|
|
|
+ 1311 END
|
|
|
+ 1312 END; .)
|
|
|
+ 1313 GetIdent<m> (. IF t = SymTab.InvalidType THEN
|
|
|
+ 1314 IF ~doLoad & firstT THEN
|
|
|
+ 1315 MGen.Drop
|
|
|
+ 1316 ELSIF doLoad THEN
|
|
|
+ 1317 MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1318 END
|
|
|
+ 1319 ELSIF SymTab.ClassOf(t) #
|
|
|
+ 1320 SymTab.ClRecord THEN
|
|
|
+ 1321 SemError(215);
|
|
|
+ 1322 t := SymTab.InvalidType;
|
|
|
+ 1323 IF doLoad THEN
|
|
|
+ 1324 MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1325 ELSIF firstT THEN
|
|
|
+ 1326 MGen.Drop
|
|
|
+ 1327 END
|
|
|
+ 1328 ELSIF ~SymTab.FieldExists(t, m) THEN
|
|
|
+ 1329 SemError(216);
|
|
|
+ 1330 t := SymTab.InvalidType;
|
|
|
+ 1331 IF doLoad THEN
|
|
|
+ 1332 MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1333 ELSIF firstT THEN
|
|
|
+ 1334 MGen.Drop
|
|
|
+ 1335 END
|
|
|
+ 1336 ELSE
|
|
|
+ 1337 loA := SymTab.FieldOffset(t, m);
|
|
|
+ 1338 elemT := SymTab.FieldType(t, m);
|
|
|
+ 1339 IF loA < 0 THEN
|
|
|
+ 1340 SemError(216);
|
|
|
+ 1341 t := SymTab.InvalidType;
|
|
|
+ 1342 IF doLoad THEN
|
|
|
+ 1343 MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1344 ELSIF firstT THEN
|
|
|
+ 1345 MGen.Drop
|
|
|
+ 1346 END
|
|
|
+ 1347 ELSE
|
|
|
+ 1348 MGen.FieldAdd(
|
|
|
+ 1349 VAL(CARDINAL, loA));
|
|
|
+ 1350 t := elemT
|
|
|
+ 1351 END
|
|
|
+ 1352 END; .)
|
|
|
+ 1353 | "[" (. firstT := ~sfx;
|
|
|
+ 1354 sfx := TRUE; lx[0] := 0C;
|
|
|
+ 1355 IF ~doLoad & firstT THEN
|
|
|
+ 1356 IF (k = SymTab.KindVar)
|
|
|
+ 1357 OR (k = SymTab.KindParam)
|
|
|
+ 1358 OR (k
|
|
|
+ 1359 = SymTab.KindVarPar) THEN
|
|
|
+ 1360 MGen.PushAddr(bn)
|
|
|
+ 1361 ELSIF k
|
|
|
+ 1362 = SymTab.KindField THEN
|
|
|
+ 1363 MGen.WithAddr(bn)
|
|
|
+ 1364 ELSE MGen.PushInt(0)
|
|
|
+ 1365 END
|
|
|
+ 1366 END; .)
|
|
|
+ 1367 Expr<it, lxI, vI, vnI> (. IF t = SymTab.InvalidType THEN
|
|
|
+ 1368 MGen.Drop;
|
|
|
+ 1369 IF doLoad THEN
|
|
|
+ 1370 MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1371 ELSE
|
|
|
+ 1372 IF ~firstT THEN
|
|
|
+ 1373 ELSE MGen.Drop
|
|
|
+ 1374 END
|
|
|
+ 1375 END
|
|
|
+ 1376 ELSIF SymTab.ClassOf(t) #
|
|
|
+ 1377 SymTab.ClArray THEN
|
|
|
+ 1378 SemError(217);
|
|
|
+ 1379 t := SymTab.InvalidType;
|
|
|
+ 1380 MGen.Drop;
|
|
|
+ 1381 IF doLoad THEN
|
|
|
+ 1382 MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1383 ELSE
|
|
|
+ 1384 IF ~firstT THEN
|
|
|
+ 1385 ELSE MGen.Drop
|
|
|
+ 1386 END
|
|
|
+ 1387 END
|
|
|
+ 1388 ELSE
|
|
|
+ 1389 clsI := SymTab.ClassOf(it);
|
|
|
+ 1390 IF (it
|
|
|
+ 1391 # SymTab.InvalidType)
|
|
|
+ 1392 & (clsI # SymTab.ClInt)
|
|
|
+ 1393 & (clsI # SymTab.ClChar)
|
|
|
+ 1394 & (clsI # SymTab.ClEnum)
|
|
|
+ 1395 & (clsI
|
|
|
+ 1396 # SymTab.ClBool) THEN
|
|
|
+ 1397 SemError(218);
|
|
|
+ 1398 t := SymTab.InvalidType;
|
|
|
+ 1399 MGen.Drop;
|
|
|
+ 1400 IF doLoad THEN
|
|
|
+ 1401 MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1402 ELSE
|
|
|
+ 1403 IF ~firstT THEN
|
|
|
+ 1404 ELSE MGen.Drop
|
|
|
+ 1405 END
|
|
|
+ 1406 END
|
|
|
+ 1407 ELSE
|
|
|
+ 1408 loA := SymTab.ArrayLo(t);
|
|
|
+ 1409 elemT := SymTab.ArrayElem(t);
|
|
|
+ 1410 esl := SymTab.TypeSlots(elemT);
|
|
|
+ 1411 IF esl = 0 THEN
|
|
|
+ 1412 SemError(230);
|
|
|
+ 1413 esl := 1
|
|
|
+ 1414 END;
|
|
|
+ 1415 IF (SymTab.ClassOf(elemT)
|
|
|
+ 1416 = SymTab.ClChar)
|
|
|
+ 1417 OR (SymTab.ClassOf(elemT)
|
|
|
+ 1418 = SymTab.ClBool) THEN
|
|
|
+ 1419 ebytes := 1
|
|
|
+ 1420 ELSE ebytes := esl * 8
|
|
|
+ 1421 END;
|
|
|
+ 1422 MGen.IdxScale(loA, ebytes);
|
|
|
+ 1423 t := elemT
|
|
|
+ 1424 END
|
|
|
+ 1425 END; .)
|
|
|
+ 1426 { ","
|
|
|
+ 1427 Expr<it, lxI, vI, vnI> (. IF t = SymTab.InvalidType THEN
|
|
|
+ 1428 MGen.Drop;
|
|
|
+ 1429 IF doLoad THEN
|
|
|
+ 1430 MGen.Drop; MGen.PushInt(0);
|
|
|
+ 1431 t := SymTab.InvalidType
|
|
|
+ 1432 END
|
|
|
+ 1433 ELSIF SymTab.ClassOf(t) #
|
|
|
+ 1434 SymTab.ClArray THEN
|
|
|
+ 1435 SemError(217);
|
|
|
+ 1436 t := SymTab.InvalidType;
|
|
|
+ 1437 MGen.Drop;
|
|
|
+ 1438 IF doLoad THEN
|
|
|
+ 1439 MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1440 END
|
|
|
+ 1441 ELSE
|
|
|
+ 1442 clsI := SymTab.ClassOf(it);
|
|
|
+ 1443 IF (it
|
|
|
+ 1444 # SymTab.InvalidType)
|
|
|
+ 1445 & (clsI # SymTab.ClInt)
|
|
|
+ 1446 & (clsI # SymTab.ClChar)
|
|
|
+ 1447 & (clsI # SymTab.ClEnum)
|
|
|
+ 1448 & (clsI
|
|
|
+ 1449 # SymTab.ClBool) THEN
|
|
|
+ 1450 SemError(218);
|
|
|
+ 1451 t := SymTab.InvalidType;
|
|
|
+ 1452 MGen.Drop;
|
|
|
+ 1453 IF doLoad THEN
|
|
|
+ 1454 MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1455 END
|
|
|
+ 1456 ELSE
|
|
|
+ 1457 loA := SymTab.ArrayLo(t);
|
|
|
+ 1458 elemT := SymTab.ArrayElem(t);
|
|
|
+ 1459 esl := SymTab.TypeSlots(elemT);
|
|
|
+ 1460 IF esl = 0 THEN
|
|
|
+ 1461 SemError(230);
|
|
|
+ 1462 esl := 1
|
|
|
+ 1463 END;
|
|
|
+ 1464 IF (SymTab.ClassOf(elemT)
|
|
|
+ 1465 = SymTab.ClChar)
|
|
|
+ 1466 OR (SymTab.ClassOf(elemT)
|
|
|
+ 1467 = SymTab.ClBool) THEN
|
|
|
+ 1468 ebytes := 1
|
|
|
+ 1469 ELSE ebytes := esl * 8
|
|
|
+ 1470 END;
|
|
|
+ 1471 MGen.IdxScale(loA, ebytes);
|
|
|
+ 1472 t := elemT
|
|
|
+ 1473 END
|
|
|
+ 1474 END; .) }
|
|
|
+ 1475 "]"
|
|
|
+ 1476 | "^" (. firstT := ~sfx;
|
|
|
+ 1477 sfx := TRUE; lx[0] := 0C;
|
|
|
+ 1478 IF ~doLoad & firstT THEN
|
|
|
+ 1479 IF (k = SymTab.KindVar)
|
|
|
+ 1480 OR (k = SymTab.KindParam)
|
|
|
+ 1481 OR (k
|
|
|
+ 1482 = SymTab.KindVarPar) THEN
|
|
|
+ 1483 MGen.PushAddr(bn)
|
|
|
+ 1484 ELSIF k
|
|
|
+ 1485 = SymTab.KindField THEN
|
|
|
+ 1486 MGen.WithAddr(bn)
|
|
|
+ 1487 ELSE MGen.PushInt(0)
|
|
|
+ 1488 END
|
|
|
+ 1489 END; .)
|
|
|
+ 1490 (. IF t = SymTab.InvalidType THEN
|
|
|
+ 1491 IF doLoad THEN
|
|
|
+ 1492 MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1493 ELSIF firstT THEN
|
|
|
+ 1494 MGen.Drop
|
|
|
+ 1495 END
|
|
|
+ 1496 ELSIF SymTab.ClassOf(t) #
|
|
|
+ 1497 SymTab.ClPtr THEN
|
|
|
+ 1498 SemError(219);
|
|
|
+ 1499 t := SymTab.InvalidType;
|
|
|
+ 1500 IF doLoad THEN
|
|
|
+ 1501 MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1502 ELSIF firstT THEN
|
|
|
+ 1503 MGen.Drop
|
|
|
+ 1504 END
|
|
|
+ 1505 ELSE
|
|
|
+ 1506 elemT := SymTab.PtrBase(t);
|
|
|
+ 1507 t := elemT;
|
|
|
+ 1508 IF doLoad THEN
|
|
|
+ 1509 IF ~(firstT
|
|
|
+ 1510 & ((k
|
|
|
+ 1511 = SymTab.KindVar)
|
|
|
+ 1512 OR (k
|
|
|
+ 1513 = SymTab.KindParam)
|
|
|
+ 1514 OR (k
|
|
|
+ 1515 = SymTab.KindVarPar)))
|
|
|
+ 1516 THEN
|
|
|
+ 1517 MGen.LoadIndir
|
|
|
+ 1518 END
|
|
|
+ 1519 ELSE
|
|
|
+ 1520 MGen.LoadIndir
|
|
|
+ 1521 END
|
|
|
+ 1522 END; .) } .
|
|
|
+ 1523 Expr <VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
|
|
|
+ 1524 VAR v: BOOLEAN; VAR vn: SymTab.Name>
|
|
|
+ 1525 (. VAR t2: SymTab.TypeIndex;
|
|
|
+ 1526 tc, op: INTEGER;
|
|
|
+ 1527 lx2: MGen.LitStr;
|
|
|
+ 1528 v2: BOOLEAN;
|
|
|
+ 1529 vn2: SymTab.Name;
|
|
|
+ 1530 r: BOOLEAN; .)
|
|
|
+ 1531 = SimExpr<t, lx, v, vn> [ Rel<op> SimExpr<t2, lx2, v2, vn2>
|
|
|
+ 1532 (. lx[0] := 0C; v := FALSE;
|
|
|
+ 1533 IF op = SymTab.OpIn THEN
|
|
|
+ 1534 IF SymTab.InCheck(t, t2) THEN
|
|
|
+ 1535 t := SymTab.BoolType();
|
|
|
+ 1536 MGen.BitIn
|
|
|
+ 1537 ELSE SemError(222);
|
|
|
+ 1538 t := SymTab.InvalidType;
|
|
|
+ 1539 MGen.Drop; MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1540 END
|
|
|
+ 1541 ELSIF (t # SymTab.InvalidType)
|
|
|
+ 1542 & (t2 # SymTab.InvalidType)
|
|
|
+ 1543 & (SymTab.ClassOf(t) = SymTab.ClArray)
|
|
|
+ 1544 & (SymTab.ClassOf(t2) = SymTab.ClArray)
|
|
|
+ 1545 & (SymTab.ClassOf(SymTab.ArrayElem(t)) = SymTab.ClChar)
|
|
|
+ 1546 & (SymTab.ClassOf(SymTab.ArrayElem(t2)) = SymTab.ClChar)
|
|
|
+ 1547 & ~SymTab.IsOpen(t) & ~SymTab.IsOpen(t2) THEN
|
|
|
+ 1548 t := SymTab.BoolType();
|
|
|
+ 1549 MGen.PushBytes(SymTab.TypeSlots(t) * 8);
|
|
|
+ 1550 MGen.PushBytes(SymTab.TypeSlots(t2) * 8);
|
|
|
+ 1551 MGen.StrComp;
|
|
|
+ 1552 IF op = SymTab.OpEq THEN MGen.Or; MGen.Not
|
|
|
+ 1553 ELSIF (op = SymTab.OpNeq1)
|
|
|
+ 1554 OR (op = SymTab.OpNeq2) THEN MGen.Or
|
|
|
+ 1555 ELSIF op = SymTab.OpLt THEN
|
|
|
+ 1556 MGen.Swap; MGen.Drop
|
|
|
+ 1557 ELSIF op = SymTab.OpLe THEN
|
|
|
+ 1558 MGen.Drop; MGen.Not
|
|
|
+ 1559 ELSIF op = SymTab.OpGt THEN
|
|
|
+ 1560 MGen.Drop
|
|
|
+ 1561 ELSE
|
|
|
+ 1562 MGen.Swap; MGen.Drop; MGen.Not
|
|
|
+ 1563 END
|
|
|
+ 1564 ELSIF (t # SymTab.InvalidType)
|
|
|
+ 1565 & (t2 # SymTab.InvalidType)
|
|
|
+ 1566 & ((SymTab.ClassOf(t) = SymTab.ClArray)
|
|
|
+ 1567 OR (SymTab.ClassOf(t) = SymTab.ClRecord)
|
|
|
+ 1568 OR (SymTab.ClassOf(t2) = SymTab.ClArray)
|
|
|
+ 1569 OR (SymTab.ClassOf(t2) = SymTab.ClRecord)) THEN
|
|
|
+ 1570 SemError(213); t := SymTab.InvalidType;
|
|
|
+ 1571 MGen.Drop; MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1572 ELSE
|
|
|
+ 1573 tc := SymTab.ClassOf(t);
|
|
|
+ 1574 IF SymTab.RelCheck(t, t2, op) THEN
|
|
|
+ 1575 t := SymTab.BoolType()
|
|
|
+ 1576 ELSE SemError(213); t := SymTab.InvalidType END;
|
|
|
+ 1577 IF t # SymTab.InvalidType THEN
|
|
|
+ 1578 r := tc = SymTab.ClReal;
|
|
|
+ 1579 IF r THEN
|
|
|
+ 1580 IF op = SymTab.OpEq THEN MGen.RealEq
|
|
|
+ 1581 ELSIF (op = SymTab.OpNeq1)
|
|
|
+ 1582 OR (op = SymTab.OpNeq2) THEN MGen.RealNe
|
|
|
+ 1583 ELSIF op = SymTab.OpLt THEN MGen.RealLt
|
|
|
+ 1584 ELSIF op = SymTab.OpLe THEN MGen.RealLe
|
|
|
+ 1585 ELSIF op = SymTab.OpGt THEN MGen.RealGt
|
|
|
+ 1586 ELSE MGen.RealGe END
|
|
|
+ 1587 ELSE
|
|
|
+ 1588 IF op = SymTab.OpEq THEN MGen.Eq
|
|
|
+ 1589 ELSIF (op = SymTab.OpNeq1)
|
|
|
+ 1590 OR (op = SymTab.OpNeq2) THEN MGen.Neq
|
|
|
+ 1591 ELSIF op = SymTab.OpLt THEN MGen.ILt
|
|
|
+ 1592 ELSIF op = SymTab.OpLe THEN MGen.ILe
|
|
|
+ 1593 ELSIF op = SymTab.OpGt THEN MGen.IGt
|
|
|
+ 1594 ELSE MGen.IGe END
|
|
|
+ 1595 END
|
|
|
+ 1596 ELSE MGen.Drop; MGen.Drop; MGen.PushInt(0)
|
|
|
+ 1597 END
|
|
|
+ 1598 END; .) ] .
|
|
|
+ 1599 Rel <VAR op: INTEGER>
|
|
|
+ 1600 = "=" (. op := SymTab.OpEq; .)
|
|
|
+ 1601 | "#" (. op := SymTab.OpNeq1; .)
|
|
|
+ 1602 | "<>" (. op := SymTab.OpNeq2; .)
|
|
|
+ 1603 | "<" (. op := SymTab.OpLt; .)
|
|
|
+ 1604 | "<=" (. op := SymTab.OpLe; .)
|
|
|
+ 1605 | ">" (. op := SymTab.OpGt; .)
|
|
|
+ 1606 | ">=" (. op := SymTab.OpGe; .)
|
|
|
+ 1607 | "IN" (. op := SymTab.OpIn; .) .
|
|
|
+ 1608 SimExpr <VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
|
|
|
+ 1609 VAR v: BOOLEAN; VAR vn: SymTab.Name>
|
|
|
+ 1610 (. VAR t2, res2: SymTab.TypeIndex;
|
|
|
+ 1611 op: INTEGER;
|
|
|
+ 1612 lx2: MGen.LitStr;
|
|
|
+ 1613 v2: BOOLEAN;
|
|
|
+ 1614 vn2: SymTab.Name;
|
|
|
+ 1615 neg, isR: BOOLEAN; .)
|
|
|
+ 1616 = (. neg := FALSE; .)
|
|
|
+ 1617 [ "+" | "-" (. neg := TRUE; .) ]
|
|
|
+ 1618 Term<t, lx, v, vn> (. IF neg THEN
|
|
|
+ 1619 v := FALSE;
|
|
|
+ 1620 IF MGen.IsLit(lx) THEN
|
|
|
+ 1621 MGen.NegFold(lx, lx)
|
|
|
+ 1622 ELSE lx[0] := 0C
|
|
|
+ 1623 END;
|
|
|
+ 1624 IF SymTab.ClassOf(t)
|
|
|
+ 1625 = SymTab.ClReal THEN
|
|
|
+ 1626 MGen.NegReal
|
|
|
+ 1627 ELSE MGen.NegInt
|
|
|
+ 1628 END
|
|
|
+ 1629 END; .)
|
|
|
+ 1630 { AddOp<op> Term<t2, lx2, v2, vn2>
|
|
|
+ 1631 (. lx[0] := 0C; v := FALSE;
|
|
|
+ 1632 IF op = SymTab.OpOr THEN
|
|
|
+ 1633 IF SymTab.BoolCheck(t) & SymTab.BoolCheck(t2) THEN
|
|
|
+ 1634 t := SymTab.BoolType()
|
|
|
+ 1635 ELSE SemError(212); t := SymTab.InvalidType END;
|
|
|
+ 1636 MGen.Or
|
|
|
+ 1637 ELSIF (t # SymTab.InvalidType)
|
|
|
+ 1638 & (t2 # SymTab.InvalidType)
|
|
|
+ 1639 & (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
+ 1640 & (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
+ 1641 IF op = SymTab.OpAdd THEN
|
|
|
+ 1642 MGen.Or
|
|
|
+ 1643 ELSE
|
|
|
+ 1644 MGen.PushBits(0FFFFFFFFFFFFFFFFH);
|
|
|
+ 1645 MGen.BitXor;
|
|
|
+ 1646 MGen.And
|
|
|
+ 1647 END
|
|
|
+ 1648 ELSE
|
|
|
+ 1649 IF SymTab.ArithCheck(t, t2, FALSE, res2) THEN t := res2
|
|
|
+ 1650 ELSE SemError(211); t := SymTab.InvalidType END;
|
|
|
+ 1651 isR := (t # SymTab.InvalidType)
|
|
|
+ 1652 & (SymTab.ClassOf(t) = SymTab.ClReal);
|
|
|
+ 1653 IF op = SymTab.OpAdd THEN
|
|
|
+ 1654 IF isR THEN MGen.RealAdd ELSE MGen.Add END
|
|
|
+ 1655 ELSE
|
|
|
+ 1656 IF isR THEN MGen.RealSub ELSE MGen.Sub END
|
|
|
+ 1657 END
|
|
|
+ 1658 END; .) } .
|
|
|
+ 1659 AddOp <VAR op: INTEGER>
|
|
|
+ 1660 = "+" (. op := SymTab.OpAdd; .)
|
|
|
+ 1661 | "-" (. op := SymTab.OpSub; .)
|
|
|
+ 1662 | "OR" (. op := SymTab.OpOr; .) .
|
|
|
+ 1663 Term <VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
|
|
|
+ 1664 VAR v: BOOLEAN; VAR vn: SymTab.Name>
|
|
|
+ 1665 (. VAR t2, res2: SymTab.TypeIndex;
|
|
|
+ 1666 op: INTEGER;
|
|
|
+ 1667 lx2: MGen.LitStr;
|
|
|
+ 1668 v2: BOOLEAN;
|
|
|
+ 1669 vn2: SymTab.Name;
|
|
|
+ 1670 isR: BOOLEAN;
|
|
|
+ 1671 mt: INTEGER; .)
|
|
|
+ 1672 = Fact<t, lx, v, vn> { MulOp<op> Fact<t2, lx2, v2, vn2>
|
|
|
+ 1673 (. lx[0] := 0C; v := FALSE;
|
|
|
+ 1674 IF op = SymTab.OpAnd THEN
|
|
|
+ 1675 IF SymTab.BoolCheck(t) & SymTab.BoolCheck(t2) THEN
|
|
|
+ 1676 t := SymTab.BoolType()
|
|
|
+ 1677 ELSE SemError(212); t := SymTab.InvalidType END;
|
|
|
+ 1678 MGen.And
|
|
|
+ 1679 ELSIF (op = SymTab.OpTimes)
|
|
|
+ 1680 & (t # SymTab.InvalidType)
|
|
|
+ 1681 & (t2 # SymTab.InvalidType)
|
|
|
+ 1682 & (SymTab.ClassOf(t) = SymTab.ClSet)
|
|
|
+ 1683 & (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
|
|
|
+ 1684 MGen.And
|
|
|
+ 1685 ELSE
|
|
|
+ 1686 IF SymTab.ArithCheck(t, t2,
|
|
|
+ 1687 (op = SymTab.OpDiv) OR (op = SymTab.OpMod),
|
|
|
+ 1688 res2) THEN t := res2
|
|
|
+ 1689 ELSE SemError(211); t := SymTab.InvalidType END;
|
|
|
+ 1690 isR := (t # SymTab.InvalidType)
|
|
|
+ 1691 & (SymTab.ClassOf(t) = SymTab.ClReal);
|
|
|
+ 1692 IF op = SymTab.OpTimes THEN
|
|
|
+ 1693 IF isR THEN MGen.RealMul ELSE MGen.MulU END
|
|
|
+ 1694 ELSIF op = SymTab.OpSlash THEN
|
|
|
+ 1695 IF isR THEN MGen.RealDiv ELSE MGen.DivI END
|
|
|
+ 1696 ELSIF op = SymTab.OpDiv THEN
|
|
|
+ 1697 MGen.DivI
|
|
|
+ 1698 ELSE
|
|
|
+ 1699 mt := MGen.TempGlobal();
|
|
|
+ 1700 MGen.ModI(mt)
|
|
|
+ 1701 END
|
|
|
+ 1702 END; .) } .
|
|
|
+ 1703 MulOp <VAR op: INTEGER>
|
|
|
+ 1704 = "*" (. op := SymTab.OpTimes; .)
|
|
|
+ 1705 | "/" (. op := SymTab.OpSlash; .)
|
|
|
+ 1706 | "DIV" (. op := SymTab.OpDiv; .)
|
|
|
+ 1707 | "MOD" (. op := SymTab.OpMod; .)
|
|
|
+ 1708 | "AND" (. op := SymTab.OpAnd; .)
|
|
|
+ 1709 | "&" (. op := SymTab.OpAnd; .) .
|
|
|
+ 1710 Fact <VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
|
|
|
+ 1711 VAR v: BOOLEAN; VAR vn: SymTab.Name>
|
|
|
+ 1712 (. VAR s: ARRAY [0 .. 255] OF CHAR;
|
|
|
+ 1713 t2, et, dt, st: SymTab.TypeIndex;
|
|
|
+ 1714 dk: INTEGER;
|
|
|
+ 1715 bnF: SymTab.Name;
|
|
|
+ 1716 lxD, lx2: MGen.LitStr;
|
|
|
+ 1717 v2: BOOLEAN;
|
|
|
+ 1718 vn2: SymTab.Name;
|
|
|
+ 1719 vi: INTEGER;
|
|
|
+ 1720 c: CARDINAL;
|
|
|
+ 1721 b: LONGCARD;
|
|
|
+ 1722 sfxF: BOOLEAN;
|
|
|
+ 1723 okF: BOOLEAN; .)
|
|
|
+ 1724 = integer (. LexString(s);
|
|
|
+ 1725 MGen.CopyName(s, lx);
|
|
|
+ 1726 v := FALSE;
|
|
|
+ 1727 IF MGen.ParseInt(s, vi) THEN
|
|
|
+ 1728 MGen.PushInt(vi)
|
|
|
+ 1729 ELSIF MGen.ParseCard(s, c) THEN
|
|
|
+ 1730 MGen.PushBits(
|
|
|
+ 1731 VAL(LONGCARD, c))
|
|
|
+ 1732 ELSE MGen.PushInt(0)
|
|
|
+ 1733 END;
|
|
|
+ 1734 t := SymTab.IntType(); .)
|
|
|
+ 1735 | real (. LexString(s);
|
|
|
+ 1736 MGen.CopyName(s, lx);
|
|
|
+ 1737 v := FALSE;
|
|
|
+ 1738 IF MGen.ParseReal(s, b) THEN
|
|
|
+ 1739 MGen.PushBits(b)
|
|
|
+ 1740 ELSE MGen.PushBits(0H)
|
|
|
+ 1741 END;
|
|
|
+ 1742 t := SymTab.RealType(); .)
|
|
|
+ 1743 | string (. LexString(s);
|
|
|
+ 1744 v := FALSE;
|
|
|
+ 1745 IF SymTab.StrLen(s) <= 3 THEN
|
|
|
+ 1746 t := SymTab.CharType();
|
|
|
+ 1747 MGen.CopyName(s, lx);
|
|
|
+ 1748 MGen.PushInt(
|
|
|
+ 1749 MGen.CharOrd(s))
|
|
|
+ 1750 ELSE t := SymTab.NewStr();
|
|
|
+ 1751 MGen.CopyName(s, lx);
|
|
|
+ 1752 MGen.EmitString(s)
|
|
|
+ 1753 END; .)
|
|
|
+ 1754 | "HIGH"
|
|
|
+ 1755 "(" DesignHead<dt, dk, bnF, FALSE, lxD>
|
|
|
+ 1756 DesignTail<dt, dk, bnF, FALSE, lxD, sfxF>
|
|
|
+ 1757 ")" (. lx[0] := 0C; v := FALSE;
|
|
|
+ 1758 IF dt = SymTab.InvalidType THEN
|
|
|
+ 1759 IF sfxF THEN MGen.Drop END;
|
|
|
+ 1760 MGen.PushInt(0);
|
|
|
+ 1761 t := SymTab.InvalidType
|
|
|
+ 1762 ELSIF SymTab.ClassOf(dt)
|
|
|
+ 1763 # SymTab.ClArray THEN
|
|
|
+ 1764 SemError(217);
|
|
|
+ 1765 IF sfxF THEN MGen.Drop END;
|
|
|
+ 1766 MGen.PushInt(0);
|
|
|
+ 1767 t := SymTab.InvalidType
|
|
|
+ 1768 ELSIF SymTab.IsOpen(dt) THEN
|
|
|
+ 1769 IF sfxF THEN MGen.Drop END;
|
|
|
+ 1770 IF (dk = SymTab.KindParam)
|
|
|
+ 1771 OR (dk
|
|
|
+ 1772 = SymTab.KindVarPar) THEN
|
|
|
+ 1773 IF SymTab.CurDepth()
|
|
|
+ 1774 = SymTab.SymDepth(bnF) THEN
|
|
|
+ 1775 MGen.LoadLocal(
|
|
|
+ 1776 SymTab.SymSlot(bnF) + 1)
|
|
|
+ 1777 ELSE
|
|
|
+ 1778 MGen.FrameAddr(
|
|
|
+ 1779 SymTab.SymSlot(bnF) + 1,
|
|
|
+ 1780 VAL(CARDINAL,
|
|
|
+ 1781 SymTab.CurDepth() - 1
|
|
|
+ 1782 - SymTab.SymDepth(bnF)));
|
|
|
+ 1783 MGen.LoadIndir
|
|
|
+ 1784 END;
|
|
|
+ 1785 MGen.PushInt(1);
|
|
|
+ 1786 MGen.Sub;
|
|
|
+ 1787 t := SymTab.IntType()
|
|
|
+ 1788 ELSE
|
|
|
+ 1789 MGen.PushInt(0);
|
|
|
+ 1790 t := SymTab.InvalidType
|
|
|
+ 1791 END
|
|
|
+ 1792 ELSE
|
|
|
+ 1793 IF sfxF THEN MGen.Drop END;
|
|
|
+ 1794 MGen.PushInt(
|
|
|
+ 1795 SymTab.ArrayHi(dt));
|
|
|
+ 1796 t := SymTab.IntType()
|
|
|
+ 1797 END; .)
|
|
|
+ 1798 | DesignHead<dt, dk, bnF, TRUE, lxD>
|
|
|
+ 1799 DesignTail<dt, dk, bnF, TRUE, lxD, sfxF>
|
|
|
+ 1800 (. t := dt;
|
|
|
+ 1801 MGen.CopyName(lxD, lx);
|
|
|
+ 1802 IF sfxF
|
|
|
+ 1803 & (t # SymTab.InvalidType)
|
|
|
+ 1804 & (SymTab.ClassOf(t)
|
|
|
+ 1805 # SymTab.ClArray)
|
|
|
+ 1806 & (SymTab.ClassOf(t)
|
|
|
+ 1807 # SymTab.ClRecord) THEN
|
|
|
+ 1808 IF (SymTab.ClassOf(t)
|
|
|
+ 1809 = SymTab.ClChar)
|
|
|
+ 1810 OR (SymTab.ClassOf(t)
|
|
|
+ 1811 = SymTab.ClBool) THEN
|
|
|
+ 1812 MGen.LoadByte
|
|
|
+ 1813 ELSE MGen.LoadIndir
|
|
|
+ 1814 END
|
|
|
+ 1815 END;
|
|
|
+ 1816 v := ~sfxF
|
|
|
+ 1817 & ((dk = SymTab.KindVar)
|
|
|
+ 1818 OR (dk = SymTab.KindParam)
|
|
|
+ 1819 OR (dk
|
|
|
+ 1820 = SymTab.KindVarPar));
|
|
|
+ 1821 MGen.CopyName(bnF, vn); .)
|
|
|
+ 1822 [ CallTail<bnF, sfxF, TRUE, okF, TRUE>
|
|
|
+ 1823 (. IF okF THEN
|
|
|
+ 1824 IF SymTab.SymKind(bnF)
|
|
|
+ 1825 = SymTab.KindProc THEN
|
|
|
+ 1826 t := SymTab.ProcRet(bnF)
|
|
|
+ 1827 ELSE
|
|
|
+ 1828 t := SymTab.InvalidType
|
|
|
+ 1829 END
|
|
|
+ 1830 ELSE t := SymTab.InvalidType
|
|
|
+ 1831 END;
|
|
|
+ 1832 lx[0] := 0C; v := FALSE; .) ]
|
|
|
+ 1833 | "("
|
|
|
+ 1834 Expr<et, lx, v, vn> ")" (. t := et; .)
|
|
|
+ 1835 | ( "NOT" | "~" )
|
|
|
+ 1836 Fact<t2, lx2, v2, vn2> (. lx[0] := 0C; v := FALSE;
|
|
|
+ 1837 IF SymTab.BoolCheck(t2) THEN
|
|
|
+ 1838 t := SymTab.BoolType()
|
|
|
+ 1839 ELSE SemError(212);
|
|
|
+ 1840 t := SymTab.InvalidType END;
|
|
|
+ 1841 MGen.Not; .)
|
|
|
+ 1842 | SetLit<st> (. lx[0] := 0C; v := FALSE;
|
|
|
+ 1843 t := st; .) .
|
|
|
+ 1844 SetLit <VAR t: SymTab.TypeIndex>
|
|
|
+ 1845 (. VAR first, et: SymTab.TypeIndex;
|
|
|
+ 1846 lxE, lxE2: MGen.LitStr;
|
|
|
+ 1847 vE, vE2: BOOLEAN;
|
|
|
+ 1848 vnE, vnE2: SymTab.Name;
|
|
|
+ 1849 hasR: BOOLEAN; .)
|
|
|
+ 1850 = "{"
|
|
|
+ 1851 (. MGen.PushInt(0);
|
|
|
+ 1852 t := SymTab.SetFor(SymTab.IntType()); .)
|
|
|
+ 1853 [ Elem<et, lxE, lxE2, hasR> (. first := et;
|
|
|
+ 1854 t := SymTab.SetFor(et);
|
|
|
+ 1855 IF hasR THEN
|
|
|
+ 1856 MGen.PushInt(1); MGen.Add;
|
|
|
+ 1857 MGen.FieldMask
|
|
|
+ 1858 ELSE MGen.Power2 END;
|
|
|
+ 1859 MGen.Or; .)
|
|
|
+ 1860 { ","
|
|
|
+ 1861 Elem<et, lxE, lxE2, hasR> (. IF ~SymTab.SetElemCheck(first, et) THEN
|
|
|
+ 1862 SemError(222) END;
|
|
|
+ 1863 IF hasR THEN
|
|
|
+ 1864 MGen.PushInt(1); MGen.Add;
|
|
|
+ 1865 MGen.FieldMask
|
|
|
+ 1866 ELSE MGen.Power2 END;
|
|
|
+ 1867 MGen.Or; .) } ]
|
|
|
+ 1868 "}" .
|
|
|
+ 1869 Elem <VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
|
|
|
+ 1870 VAR lx2: MGen.LitStr; VAR hasR: BOOLEAN>
|
|
|
+ 1871 (. VAR t2: SymTab.TypeIndex;
|
|
|
+ 1872 vD, vD2: BOOLEAN;
|
|
|
+ 1873 vnD, vnD2: SymTab.Name; .)
|
|
|
+ 1874 = Expr<t, lx, vD, vnD> (. hasR := FALSE;
|
|
|
+ 1875 lx2[0] := 0C; .)
|
|
|
+ 1876 [ ".."
|
|
|
+ 1877 Expr<t2, lx2, vD2, vnD2> (. IF ~SymTab.SetElemCheck(t, t2) THEN
|
|
|
+ 1878 SemError(222) END;
|
|
|
+ 1879 hasR := TRUE; .) ] .
|
|
|
+ 1880
|
|
|
+ 1881 GetIdent <VAR n: SymTab.Name>
|
|
|
+ 1882 = ident (. LexName(n); .) .
|
|
|
+ 1883
|
|
|
+ 1884 END M2c.
|
|
|
+
|
|
|
+ 0 errors
|
|
|
+
|
|
|
|
|
|
Statistics:
|
|
|
|
|
|
- nr of terminals: 72 (limit 400)
|
|
|
- nr of non-terminals: 54 (limit 210)
|
|
|
- nr of pragmas: 0 (limit 428)
|
|
|
- nr of symbolnodes: 126 (limit 500)
|
|
|
- nr of graphnodes: 522 (limit 1500)
|
|
|
+ nr of terminals: 75 (limit 400)
|
|
|
+ nr of non-terminals: 56 (limit 210)
|
|
|
+ nr of pragmas: 0 (limit 425)
|
|
|
+ nr of symbolnodes: 131 (limit 500)
|
|
|
+ nr of graphnodes: 547 (limit 1500)
|
|
|
nr of conditionsets: 7 (limit 100)
|
|
|
nr of charactersets: 9 (limit 250)
|
|
|
|
