Debian Codegraph @

gcc/testsuite/gm2/projects/pim/run/pass/tower/AdvParse.mod

raw
1 (* it is advisable not to edit this file as it was automatically generated from the grammer file AdvParse.bnf *)
2 # 2 "AdvParse.bnf"
3
4 IMPLEMENTATION MODULE AdvParse ;
5
6 (*
7 Author : Gaius Mulley
8 Title : AdvParse
9 Date : 16/7/2005
10 SYSTEM : GNU Modula-2
11 Description: parses maps.
12 *)
13
14 FROM libc IMPORT printf ;
15 FROM SYSTEM IMPORT ADDRESS ;
16 FROM DynamicStrings IMPORT String, string, InitStringCharStar, KillString,
17 InitString, ConCat, ConCatChar, Mark ;
18 FROM StringConvert IMPORT stoi ;
19 FROM advflex IMPORT toktype, OpenSource, CloseSource, error, GetToken,
20 currenttoken, currentinteger ;
21 FROM AdvMap IMPORT Rooms, Line, DoorStatus, Door, Room, Treasure,
22 ActualNoOfRooms, MaxNoOfRooms,
23 WallsPerRoom, DoorsPerRoom, TreasureKind ;
24 FROM AdvUtil IMPORT HideTreasure ;
25
26 FROM AdvMath IMPORT MaxNoOfTreasures ;
27
28
29 CONST
30 Debugging = TRUE ;
31
32 TYPE
33 SetOfTok = SET OF toktype ;
34
35 VAR
36 LastInt,
37 ExitValue : INTEGER ;
38
39 CurDoor,
40 CurWall,
41 CurRoom : CARDINAL ;
42
43
44 (*
45 Min -
46 *)
47
48 PROCEDURE Min (a, b: INTEGER) : INTEGER ;
49 BEGIN
50 IF a<b
51 THEN
52 RETURN( a )
53 ELSE
54 RETURN( b )
55 END
56 END Min ;
57
58
59 (*
60 Max -
61 *)
62
63 PROCEDURE Max (a, b: INTEGER) : INTEGER ;
64 BEGIN
65 IF a>b
66 THEN
67 RETURN( a )
68 ELSE
69 RETURN( b )
70 END
71 END Max ;
72
73
74 (*
75 OpenFile - attempts to open a file, mapfile.
76 *)
77
78 PROCEDURE OpenFile (mapfile: ADDRESS) : INTEGER ;
79 VAR
80 r: INTEGER ;
81 BEGIN
82 ExitValue := 0 ;
83 IF OpenSource (mapfile)
84 THEN
85 RETURN 0
86 ELSE
87 r := printf ("cannot open file: %s\n", mapfile) ;
88 RETURN 1
89 END ;
90 END OpenFile ;
91
92
93 (*
94 CloseFile -
95 *)
96
97 PROCEDURE CloseFile ;
98 BEGIN
99 CloseSource
100 END CloseFile ;
101
102 (*
103 expecting token set defined as an enumerated type
104 (eoftok, roomtok, doortok, walltok, treasuretok, attok, leadstok, totok, statustok, closedtok, opentok, secrettok, istok, endtok, enddottok, integertok, randomizetok) ;
105 *)
106
107 (* %%%FORWARD%%%
108 PROCEDURE Integer (stopset: SetOfTok) ; FORWARD ;
109 PROCEDURE FileUnit (stopset: SetOfTok) ; FORWARD ;
110 PROCEDURE RoomDesc (stopset: SetOfTok) ; FORWARD ;
111 PROCEDURE WallDesc (stopset: SetOfTok) ; FORWARD ;
112 PROCEDURE WallCoords (stopset: SetOfTok) ; FORWARD ;
113 PROCEDURE DoorDesc (stopset: SetOfTok) ; FORWARD ;
114 PROCEDURE DoorCoords (stopset: SetOfTok) ; FORWARD ;
115 PROCEDURE Status (stopset: SetOfTok) ; FORWARD ;
116 PROCEDURE TreasureDesc (stopset: SetOfTok) ; FORWARD ;
117 PROCEDURE RandomTreasure (stopset: SetOfTok) ; FORWARD ;
118 %%%FORWARD%%% *)
119
120 (*
121 DescribeStop - issues a message explaining what tokens were expected
122 *)
123
124 PROCEDURE DescribeStop (stopset: SetOfTok) : String ;
125 VAR
126 n : CARDINAL ;
127 str,
128 message: String ;
129 BEGIN
130 n := 0 ;
131 message := InitString('') ;
132 IF randomizetok IN stopset
133 THEN
134 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`RANDOMIZE'"))) ; INC(n)
135 END ;
136 IF integertok IN stopset
137 THEN
138 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`integer number'"))) ; INC(n)
139 END ;
140 IF enddottok IN stopset
141 THEN
142 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`END.'"))) ; INC(n)
143 END ;
144 IF endtok IN stopset
145 THEN
146 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`END'"))) ; INC(n)
147 END ;
148 IF istok IN stopset
149 THEN
150 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`IS'"))) ; INC(n)
151 END ;
152 IF secrettok IN stopset
153 THEN
154 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`SECRET'"))) ; INC(n)
155 END ;
156 IF opentok IN stopset
157 THEN
158 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`OPEN'"))) ; INC(n)
159 END ;
160 IF closedtok IN stopset
161 THEN
162 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`CLOSED'"))) ; INC(n)
163 END ;
164 IF statustok IN stopset
165 THEN
166 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`STATUS'"))) ; INC(n)
167 END ;
168 IF totok IN stopset
169 THEN
170 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`TO'"))) ; INC(n)
171 END ;
172 IF leadstok IN stopset
173 THEN
174 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`LEADS'"))) ; INC(n)
175 END ;
176 IF attok IN stopset
177 THEN
178 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`AT'"))) ; INC(n)
179 END ;
180 IF treasuretok IN stopset
181 THEN
182 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`TREASURE'"))) ; INC(n)
183 END ;
184 IF walltok IN stopset
185 THEN
186 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`WALL'"))) ; INC(n)
187 END ;
188 IF doortok IN stopset
189 THEN
190 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`DOOR'"))) ; INC(n)
191 END ;
192 IF roomtok IN stopset
193 THEN
194 message := ConCat(ConCatChar(message, ' '), Mark(InitString("`ROOM'"))) ; INC(n)
195 END ;
196 IF eoftok IN stopset
197 THEN
198 (* eoftok has no token name (needed to generate error messages) *)
199 END ;
200
201 IF n=0
202 THEN
203 str := InitString(' syntax error') ;
204 message := KillString(message) ;
205 ELSIF n=1
206 THEN
207 str := ConCat(message, Mark(InitString(' missing '))) ;
208 ELSE
209 str := ConCat(InitString(' expecting one of'), message) ;
210 message := KillString(message) ;
211 END ;
212 RETURN( str )
213 END DescribeStop ;
214
215
216 (*
217 DescribeError - issues a message explaining what tokens were expected
218 *)
219
220 PROCEDURE DescribeError (stopset: SetOfTok) ;
221 VAR
222 str: String ;
223 BEGIN
224 str := InitString('') ;
225 CASE currenttoken OF
226
227 randomizetok: str := ConCat(InitString("syntax error, found `RANDOMIZE'"), Mark(str)) |
228 integertok: str := ConCat(InitString("syntax error, found `integer number'"), Mark(str)) |
229 enddottok: str := ConCat(InitString("syntax error, found `END.'"), Mark(str)) |
230 endtok: str := ConCat(InitString("syntax error, found `END'"), Mark(str)) |
231 istok: str := ConCat(InitString("syntax error, found `IS'"), Mark(str)) |
232 secrettok: str := ConCat(InitString("syntax error, found `SECRET'"), Mark(str)) |
233 opentok: str := ConCat(InitString("syntax error, found `OPEN'"), Mark(str)) |
234 closedtok: str := ConCat(InitString("syntax error, found `CLOSED'"), Mark(str)) |
235 statustok: str := ConCat(InitString("syntax error, found `STATUS'"), Mark(str)) |
236 totok: str := ConCat(InitString("syntax error, found `TO'"), Mark(str)) |
237 leadstok: str := ConCat(InitString("syntax error, found `LEADS'"), Mark(str)) |
238 attok: str := ConCat(InitString("syntax error, found `AT'"), Mark(str)) |
239 treasuretok: str := ConCat(InitString("syntax error, found `TREASURE'"), Mark(str)) |
240 walltok: str := ConCat(InitString("syntax error, found `WALL'"), Mark(str)) |
241 doortok: str := ConCat(InitString("syntax error, found `DOOR'"), Mark(str)) |
242 roomtok: str := ConCat(InitString("syntax error, found `ROOM'"), Mark(str)) |
243 eoftok: str := ConCat(InitString("syntax error, found `'"), Mark(str))
244 ELSE
245 END ;
246 ErrorString(str) ;
247 END DescribeError ;
248 # 99 "AdvParse.bnf"
249
250
251
252 (*
253 ErrorArray -
254 *)
255
256 PROCEDURE ErrorArray (a: ARRAY OF CHAR) ;
257 BEGIN
258 ErrorString(InitString(a))
259 END ErrorArray ;
260
261
262 (*
263 ErrorString -
264 *)
265
266 PROCEDURE ErrorString (s: String) ;
267 BEGIN
268 error(string(s)) ;
269 ExitValue := 1
270 END ErrorString ;
271
272
273 (*
274 SyntaxError - after a syntax error we skip all tokens up until we reach
275 a stop symbol.
276 *)
277
278 PROCEDURE SyntaxError (stopset: SetOfTok) ;
279 VAR
280 r: INTEGER ;
281 BEGIN
282 DescribeError(stopset) ;
283 IF Debugging
284 THEN
285 r := printf('\nskipping token *** ')
286 END ;
287 WHILE NOT (currenttoken IN stopset)
288 DO
289 GetToken
290 END ;
291 IF Debugging
292 THEN
293 r := printf(' ***\n')
294 END ;
295 ExitValue := 1
296 END SyntaxError ;
297
298
299 (*
300 SyntaxCheck -
301 *)
302
303 PROCEDURE SyntaxCheck (stopset: SetOfTok) ;
304 BEGIN
305 IF NOT (currenttoken IN stopset)
306 THEN
307 SyntaxError(stopset)
308 END
309 END SyntaxCheck ;
310
311
312 (*
313 WarnMissingToken - generates a warning message about a missing token, t.
314 *)
315
316 PROCEDURE WarnMissingToken (t: toktype) ;
317 VAR
318 s : SetOfTok ;
319 str: String ;
320 BEGIN
321 s := SetOfTok{t} ;
322 str := DescribeStop(s) ;
323
324 str := ConCat(InitString('syntax error,'), Mark(str)) ;
325 ErrorString(str)
326 END WarnMissingToken ;
327
328
329 (*
330 MissingToken - generates a warning message about a missing token, t.
331 *)
332
333 PROCEDURE MissingToken (t: toktype) ;
334 VAR
335 r: INTEGER ;
336 BEGIN
337 WarnMissingToken(t)
338 END MissingToken ;
339
340
341 (*
342 InStopSet
343 *)
344
345 PROCEDURE InStopSet (t: toktype; stopset: SetOfTok) : BOOLEAN ;
346 BEGIN
347 RETURN t IN stopset
348 END InStopSet ;
349
350
351 (*
352 Expect -
353 *)
354
355 PROCEDURE Expect (t: toktype; stopset: SetOfTok) ;
356 BEGIN
357 IF currenttoken=t
358 THEN
359 GetToken
360 ELSE
361 MissingToken(t)
362 END ;
363 SyntaxCheck(stopset)
364 END Expect ;
365
366
367 PROCEDURE ParseMap (a: ADDRESS) : INTEGER ;
368 VAR
369 r: INTEGER ;
370 BEGIN
371 r := OpenFile(a) ;
372 IF r=0
373 THEN
374 GetToken ;
375 FileUnit(SetOfTok{eoftok}) ;
376 CloseFile ;
377 RETURN( ExitValue )
378 ELSE
379 RETURN( r )
380 END
381 END ParseMap ;
382
383
384 (*
385 Integer -
386 *)
387
388 PROCEDURE Integer (stopset: SetOfTok) ;
389 BEGIN
390 LastInt := currentinteger ;
391 Expect(integertok, stopset)
392 END Integer ;
393
394
395 (*
396 Integer :=
397
398 first symbols:integertok
399
400 cannot reachend
401 *)
402 (*
403 FileUnit := RoomDesc { RoomDesc } [ RandomTreasure ] 'END.'
404
405 first symbols:roomtok
406
407 cannot reachend
408 *)
409
410 # 274 "AdvParse.bnf"
411 PROCEDURE FileUnit (stopset: SetOfTok) ;
412 # 274 "AdvParse.bnf"
413 BEGIN
414 # 274 "AdvParse.bnf"
415 RoomDesc(stopset + SetOfTok{enddottok, roomtok, randomizetok}) ;
416 # 274 "AdvParse.bnf"
417 WHILE currenttoken=roomtok DO
418 RoomDesc(stopset + SetOfTok{enddottok, randomizetok, roomtok}) ;
419 END (* while *) ;
420 # 274 "AdvParse.bnf"
421 IF currenttoken=randomizetok
422 THEN
423 RandomTreasure(stopset + SetOfTok{enddottok}) ;
424 END ;
425 # 274 "AdvParse.bnf"
426 Expect(enddottok, stopset) ;
427 END FileUnit ;
428
429
430 (*
431 RoomDesc := 'ROOM' Integer
432 % VAR r: INTEGER ; %
433
434 % CurRoom := LastInt ;
435 ActualNoOfRooms := Max(CurRoom,
436 ActualNoOfRooms) ;
437 WITH Rooms[CurRoom] DO
438 NoOfWalls := 0 ;
439 NoOfDoors := 0 ;
440 Treasures := {}
441 END ;
442 IF Debugging
443 THEN
444 r := printf('reading room %d\n', CurRoom)
445 END %
446 { WallDesc | DoorDesc | TreasureDesc } 'END'
447
448 first symbols:roomtok
449
450 cannot reachend
451 *)
452
453 # 276 "AdvParse.bnf"
454 PROCEDURE RoomDesc (stopset: SetOfTok) ;
455 VAR
456 r: INTEGER ;
457 # 276 "AdvParse.bnf"
458 BEGIN
459 # 276 "AdvParse.bnf"
460 Expect(roomtok, stopset + SetOfTok{integertok}) ;
461 # 276 "AdvParse.bnf"
462 Integer(stopset + SetOfTok{endtok, walltok, doortok, treasuretok}) ;
463 # 276 "AdvParse.bnf"
464 # 277 "AdvParse.bnf"
465 # 288 "AdvParse.bnf"
466 CurRoom := LastInt ;
467 ActualNoOfRooms := Max(CurRoom,
468 ActualNoOfRooms) ;
469 WITH Rooms[CurRoom] DO
470 NoOfWalls := 0 ;
471 NoOfDoors := 0 ;
472 Treasures := {}
473 END ;
474 IF Debugging
475 THEN
476 r := printf('reading room %d\n', CurRoom)
477 END ;
478 # 289 "AdvParse.bnf"
479 IF (currenttoken IN SetOfTok{treasuretok, doortok, walltok})
480 THEN
481 (* seen optional { | } expression *)
482 WHILE (currenttoken IN SetOfTok{treasuretok, doortok, walltok}) DO
483 # 289 "AdvParse.bnf"
484 IF currenttoken=walltok
485 THEN
486 WallDesc(stopset + SetOfTok{endtok, treasuretok, doortok, walltok}) ;
487 # 289 "AdvParse.bnf"
488 ELSIF currenttoken=doortok
489 THEN
490 DoorDesc(stopset + SetOfTok{endtok, treasuretok, doortok, walltok}) ;
491 # 289 "AdvParse.bnf"
492 ELSIF currenttoken=treasuretok
493 THEN
494 TreasureDesc(stopset + SetOfTok{endtok, treasuretok, doortok, walltok}) ;
495 END ;
496 (* end of optional { | } expression *)
497 END ;
498 END ;
499 # 289 "AdvParse.bnf"
500 Expect(endtok, stopset) ;
501 END RoomDesc ;
502
503
504 (*
505 WallDesc := 'WALL' WallCoords { WallCoords }
506
507 first symbols:walltok
508
509 cannot reachend
510 *)
511
512 # 291 "AdvParse.bnf"
513 PROCEDURE WallDesc (stopset: SetOfTok) ;
514 # 291 "AdvParse.bnf"
515 BEGIN
516 # 291 "AdvParse.bnf"
517 Expect(walltok, stopset + SetOfTok{integertok}) ;
518 # 291 "AdvParse.bnf"
519 WallCoords(stopset + SetOfTok{integertok}) ;
520 # 291 "AdvParse.bnf"
521 WHILE currenttoken=integertok DO
522 WallCoords(stopset + SetOfTok{integertok}) ;
523 END (* while *) ;
524 END WallDesc ;
525
526
527 (*
528 WallCoords :=
529 % WITH Rooms[CurRoom] DO
530 INC(NoOfWalls) ;
531 IF NoOfWalls>WallsPerRoom
532 THEN
533 ErrorArray('too many walls') ;
534 NoOfWalls := WallsPerRoom
535 END ;
536 CurWall := NoOfWalls
537 END %
538 Integer
539 % VAR x1, y1, x2, y2: INTEGER ; %
540
541 % x1 := LastInt %
542 Integer
543 % y1 := LastInt %
544 Integer
545 % x2 := LastInt %
546 Integer
547 % y2 := LastInt ;
548 WITH Rooms[CurRoom].Walls[CurWall] DO
549 X1 := Min(x1, x2) ;
550 Y1 := Min(y1, y2) ;
551 X2 := Max(x1, x2) ;
552 Y2 := Max(y1, y2) ;
553 IF (X1#X2) AND (Y1#Y2)
554 THEN
555 error(string(InitString("not allowed diagonal wall")))
556 END
557 END %
558
559
560 first symbols:integertok
561
562 cannot reachend
563 *)
564
565 # 293 "AdvParse.bnf"
566 PROCEDURE WallCoords (stopset: SetOfTok) ;
567 VAR
568 x1, y1, x2, y2: INTEGER ;
569 # 293 "AdvParse.bnf"
570 BEGIN
571 # 293 "AdvParse.bnf"
572 # 301 "AdvParse.bnf"
573 WITH Rooms[CurRoom] DO
574 INC(NoOfWalls) ;
575 IF NoOfWalls>WallsPerRoom
576 THEN
577 ErrorArray('too many walls') ;
578 NoOfWalls := WallsPerRoom
579 END ;
580 CurWall := NoOfWalls
581 END ;
582 # 302 "AdvParse.bnf"
583 Integer(stopset + SetOfTok{integertok}) ;
584 # 302 "AdvParse.bnf"
585 # 303 "AdvParse.bnf"
586 x1 := LastInt ;
587 # 304 "AdvParse.bnf"
588 Integer(stopset + SetOfTok{integertok}) ;
589 # 304 "AdvParse.bnf"
590 y1 := LastInt ;
591 # 306 "AdvParse.bnf"
592 Integer(stopset + SetOfTok{integertok}) ;
593 # 306 "AdvParse.bnf"
594 x2 := LastInt ;
595 # 308 "AdvParse.bnf"
596 Integer(stopset) ;
597 # 308 "AdvParse.bnf"
598 # 318 "AdvParse.bnf"
599 y2 := LastInt ;
600 WITH Rooms[CurRoom].Walls[CurWall] DO
601 X1 := Min(x1, x2) ;
602 Y1 := Min(y1, y2) ;
603 X2 := Max(x1, x2) ;
604 Y2 := Max(y1, y2) ;
605 IF (X1#X2) AND (Y1#Y2)
606 THEN
607 error(string(InitString("not allowed diagonal wall")))
608 END
609 END ;
610 END WallCoords ;
611
612
613 (*
614 DoorDesc := 'DOOR' DoorCoords { DoorCoords }
615
616 first symbols:doortok
617
618 cannot reachend
619 *)
620
621 # 321 "AdvParse.bnf"
622 PROCEDURE DoorDesc (stopset: SetOfTok) ;
623 # 321 "AdvParse.bnf"
624 BEGIN
625 # 321 "AdvParse.bnf"
626 Expect(doortok, stopset + SetOfTok{integertok}) ;
627 # 321 "AdvParse.bnf"
628 DoorCoords(stopset + SetOfTok{integertok}) ;
629 # 321 "AdvParse.bnf"
630 WHILE currenttoken=integertok DO
631 DoorCoords(stopset + SetOfTok{integertok}) ;
632 END (* while *) ;
633 END DoorDesc ;
634
635
636 (*
637 DoorCoords :=
638 % WITH Rooms[CurRoom] DO
639 INC(NoOfDoors) ;
640 IF NoOfDoors>DoorsPerRoom
641 THEN
642 ErrorArray('too many doors') ;
643 NoOfDoors := DoorsPerRoom
644 END ;
645 CurDoor := NoOfDoors
646 END %
647 Integer
648 % VAR x1, y1, x2, y2: INTEGER ; %
649
650 % x1 := LastInt %
651 Integer
652 % y1 := LastInt %
653 Integer
654 % x2 := LastInt %
655 Integer
656 % y2 := LastInt ;
657 WITH Rooms[CurRoom].Doors[CurDoor].Position DO
658 X1 := Min(x1, x2) ;
659 Y1 := Min(y1, y2) ;
660 X2 := Max(x1, x2) ;
661 Y2 := Max(y1, y2) ;
662 IF (X1#X2) AND (Y1#Y2)
663 THEN
664 error(string(InitString("not allowed diagonal door")))
665 END
666
667 END %
668 Status 'LEADS' 'TO' Integer
669 % Rooms[CurRoom].Doors[CurDoor].LeadsTo := LastInt %
670
671
672 first symbols:integertok
673
674 cannot reachend
675 *)
676
677 # 323 "AdvParse.bnf"
678 PROCEDURE DoorCoords (stopset: SetOfTok) ;
679 VAR
680 x1, y1, x2, y2: INTEGER ;
681 # 323 "AdvParse.bnf"
682 BEGIN
683 # 323 "AdvParse.bnf"
684 # 331 "AdvParse.bnf"
685 WITH Rooms[CurRoom] DO
686 INC(NoOfDoors) ;
687 IF NoOfDoors>DoorsPerRoom
688 THEN
689 ErrorArray('too many doors') ;
690 NoOfDoors := DoorsPerRoom
691 END ;
692 CurDoor := NoOfDoors
693 END ;
694 # 332 "AdvParse.bnf"
695 Integer(stopset + SetOfTok{integertok}) ;
696 # 332 "AdvParse.bnf"
697 # 333 "AdvParse.bnf"
698 x1 := LastInt ;
699 # 334 "AdvParse.bnf"
700 Integer(stopset + SetOfTok{integertok}) ;
701 # 334 "AdvParse.bnf"
702 y1 := LastInt ;
703 # 336 "AdvParse.bnf"
704 Integer(stopset + SetOfTok{integertok}) ;
705 # 336 "AdvParse.bnf"
706 x2 := LastInt ;
707 # 338 "AdvParse.bnf"
708 Integer(stopset + SetOfTok{statustok}) ;
709 # 338 "AdvParse.bnf"
710 # 349 "AdvParse.bnf"
711 y2 := LastInt ;
712 WITH Rooms[CurRoom].Doors[CurDoor].Position DO
713 X1 := Min(x1, x2) ;
714 Y1 := Min(y1, y2) ;
715 X2 := Max(x1, x2) ;
716 Y2 := Max(y1, y2) ;
717 IF (X1#X2) AND (Y1#Y2)
718 THEN
719 error(string(InitString("not allowed diagonal door")))
720 END
721
722 END ;
723 # 352 "AdvParse.bnf"
724 Status(stopset + SetOfTok{leadstok}) ;
725 # 352 "AdvParse.bnf"
726 Expect(leadstok, stopset + SetOfTok{totok}) ;
727 # 352 "AdvParse.bnf"
728 Expect(totok, stopset + SetOfTok{integertok}) ;
729 # 352 "AdvParse.bnf"
730 Integer(stopset) ;
731 # 352 "AdvParse.bnf"
732 Rooms[CurRoom].Doors[CurDoor].LeadsTo := LastInt ;
733 END DoorCoords ;
734
735
736 (*
737 Status := 'STATUS' ( 'OPEN'
738 % Rooms[CurRoom].Doors[CurDoor].StateOfDoor := Open %
739 | 'CLOSED'
740 % Rooms[CurRoom].Doors[CurDoor].StateOfDoor := Closed %
741 | 'SECRET'
742 % Rooms[CurRoom].Doors[CurDoor].StateOfDoor := Secret %
743 )
744
745 first symbols:statustok
746
747 cannot reachend
748 *)
749
750 # 355 "AdvParse.bnf"
751 PROCEDURE Status (stopset: SetOfTok) ;
752 # 355 "AdvParse.bnf"
753 BEGIN
754 # 355 "AdvParse.bnf"
755 Expect(statustok, stopset + SetOfTok{opentok, closedtok, secrettok}) ;
756 # 355 "AdvParse.bnf"
757 IF currenttoken=opentok
758 THEN
759 Expect(opentok, stopset) ;
760 # 355 "AdvParse.bnf"
761 Rooms[CurRoom].Doors[CurDoor].StateOfDoor := Open ;
762 # 356 "AdvParse.bnf"
763 ELSIF currenttoken=closedtok
764 THEN
765 Expect(closedtok, stopset) ;
766 # 356 "AdvParse.bnf"
767 Rooms[CurRoom].Doors[CurDoor].StateOfDoor := Closed ;
768 # 357 "AdvParse.bnf"
769 ELSIF currenttoken=secrettok
770 THEN
771 Expect(secrettok, stopset) ;
772 # 357 "AdvParse.bnf"
773 Rooms[CurRoom].Doors[CurDoor].StateOfDoor := Secret ;
774 ELSE
775 ErrorArray('expecting one of: SECRET CLOSED OPEN')
776 END ;
777 END Status ;
778
779
780 (*
781 TreasureDesc := 'TREASURE' 'AT' Integer
782 % VAR x, y: INTEGER ; %
783
784 % x := LastInt %
785 Integer
786 % y := LastInt %
787 'IS' Integer
788 % WITH Treasure[LastInt] DO
789 Xpos := x ;
790 Ypos := y ;
791 Rm := CurRoom
792 END ;
793 INCL(Rooms[CurRoom].Treasures, LastInt) %
794
795
796 first symbols:treasuretok
797
798 cannot reachend
799 *)
800
801 # 361 "AdvParse.bnf"
802 PROCEDURE TreasureDesc (stopset: SetOfTok) ;
803 VAR
804 x, y: INTEGER ;
805 # 361 "AdvParse.bnf"
806 BEGIN
807 # 361 "AdvParse.bnf"
808 Expect(treasuretok, stopset + SetOfTok{attok}) ;
809 # 361 "AdvParse.bnf"
810 Expect(attok, stopset + SetOfTok{integertok}) ;
811 # 362 "AdvParse.bnf"
812 Integer(stopset + SetOfTok{integertok}) ;
813 # 362 "AdvParse.bnf"
814 # 363 "AdvParse.bnf"
815 x := LastInt ;
816 # 364 "AdvParse.bnf"
817 Integer(stopset + SetOfTok{istok}) ;
818 # 364 "AdvParse.bnf"
819 y := LastInt ;
820 # 365 "AdvParse.bnf"
821 Expect(istok, stopset + SetOfTok{integertok}) ;
822 # 365 "AdvParse.bnf"
823 Integer(stopset) ;
824 # 365 "AdvParse.bnf"
825 # 370 "AdvParse.bnf"
826 WITH Treasure[LastInt] DO
827 Xpos := x ;
828 Ypos := y ;
829 Rm := CurRoom ;
830 kind := onfloor
831 END ;
832 INCL(Rooms[CurRoom].Treasures, VAL(CARDINAL, LastInt))
833 END TreasureDesc ;
834
835
836 (*
837 RandomTreasure := 'RANDOMIZE' 'TREASURE' Integer
838 % HideTreasure(LastInt) %
839 { Integer
840 % HideTreasure(LastInt) %
841 }
842
843 first symbols:randomizetok
844
845 cannot reachend
846 *)
847
848 # 373 "AdvParse.bnf"
849 PROCEDURE RandomTreasure (stopset: SetOfTok) ;
850 # 373 "AdvParse.bnf"
851 BEGIN
852 # 373 "AdvParse.bnf"
853 Expect(randomizetok, stopset + SetOfTok{treasuretok}) ;
854 # 373 "AdvParse.bnf"
855 Expect(treasuretok, stopset + SetOfTok{integertok}) ;
856 # 373 "AdvParse.bnf"
857 Integer(stopset + SetOfTok{integertok}) ;
858 # 373 "AdvParse.bnf"
859 HideTreasure(LastInt) ;
860 # 374 "AdvParse.bnf"
861 WHILE currenttoken=integertok DO
862 Integer(stopset + SetOfTok{integertok}) ;
863 # 374 "AdvParse.bnf"
864 HideTreasure(LastInt) ;
865 END (* while *) ;
866 END RandomTreasure ;
867
868
869 # 245 "AdvParse.bnf"
870
871
872
873 END AdvParse.