| blob | e57c4980a7f73b54ceaba1024bcaf22028131842 |
1 /* ------------------------------------------------------------------------- */
2 /* "states" : Statement translator */
3 /* */
4 /* Part of Inform 6.33 */
5 /* copyright (c) Graham Nelson 1993 - 2014 */
6 /* */
7 /* ------------------------------------------------------------------------- */
17 else
22 }
23 }
24 else
28 }
30 }
37 }
44 }
50 /* An action statement has the form <ACTION NOUN SECOND, ACTOR>
51 or <<ACTION NOUN SECOND, ACTOR>>. It simply compiles into a call
52 to R_Process() with those four arguments. (The latter form,
53 with double brackets, means "return true afterwards".)
55 The R_Process() function should be supplied by the library,
56 although a stub is defined in the veneer.
58 The NOUN, SECOND, and ACTOR arguments are optional. If not
59 supplied, R_Process() will be called with fewer arguments.
60 (But if you supply ACTOR, it must be preceded by a comma.
61 <ACTION, ACTOR> is equivalent to <ACTION 0 0, ACTOR>.)
63 To complicate life, the ACTION argument may be a bare action
64 name or a parenthesized expression. (So <Take> is equivalent
65 to <(##Take)>.) We have to peek at the first token, checking
66 whether it's an open-paren, to distinguish these cases.
68 You may ask why the ACTOR argument is last; the "natural"
69 Inform ordering would be "<floyd, take ball>". True! Sadly,
70 Inform's lexer isn't smart enough to parse this consistently,
71 so we can't do it.
72 */
78 }
81 /* Peek at the next token; see if it's an open-paren. */
86 }
87 else
90 }
102 }
108 }
110 {
112 }
115 {
117 {
119 }
124 {
126 }
127 }
134 }
135 }
146 else
149 else
157 else
160 else
169 else
172 else
182 else
185 /* if V3 or earlier, we've already displayed an error */
188 }
192 }
236 }
241 }
242 }
245 {
252 }
257 next_label++;
260 }
264 }
269 /* print <printlist> -------------------------------------------------- */
270 /* print_ret <printlist> ---------------------------------------------- */
271 /* <literal-string> --------------------------------------------------- */
272 /* */
273 /* <printlist> is a comma-separated list of items: */
274 /* */
275 /* <literal-string> */
276 /* <other-expression> */
277 /* (char) <expression> */
278 /* (address) <expression> */
279 /* (string) <expression> */
280 /* (a) <expression> */
281 /* (the) <expression> */
282 /* (The) <expression> */
283 /* (name) <expression> */
284 /* (number) <expression> */
285 /* (property) <expression> */
286 /* (<routine>) <expression> */
287 /* (object) <expression> (for use in low-level code only) */
288 /* --------------------------------------------------------------------- */
290 do
307 }
309 }
311 }
316 }
318 }
340 }
343 {
350 }
361 }
372 }
383 }
414 token_text);
415 }
423 }
424 else
430 }
433 PrintByRoutine:
444 else
456 }
457 }
464 }
472 }
476 count++;
482 }
490 }
491 }
496 /* print <printlist> -------------------------------------------------- */
497 /* print_ret <printlist> ---------------------------------------------- */
498 /* <literal-string> --------------------------------------------------- */
499 /* */
500 /* <printlist> is a comma-separated list of items: */
501 /* */
502 /* <literal-string> */
503 /* <other-expression> */
504 /* (char) <expression> */
505 /* (address) <expression> */
506 /* (string) <expression> */
507 /* (a) <expression> */
508 /* (A) <expression> */
509 /* (the) <expression> */
510 /* (The) <expression> */
511 /* (name) <expression> */
512 /* (number) <expression> */
513 /* (property) <expression> */
514 /* (<routine>) <expression> */
515 /* (object) <expression> (for use in low-level code only) */
516 /* --------------------------------------------------------------------- */
518 do
519 {
523 /* We can't compile a string into the instruction,
524 so this always goes into the string area. */
540 }
542 }
544 }
566 }
569 {
576 }
583 stack_pointer);
584 }
598 else
605 }
616 }
625 stack_pointer);
652 token_text);
653 }
661 }
662 else
668 }
671 PrintByRoutine:
679 AO2);
688 }
689 }
696 }
704 }
708 count++;
714 }
720 {
725 }
726 }
740 {
746 next_label++;
747 }
748 else
754 }
756 }
762 }
764 /* Interesting point of Inform grammar: a statement can only
765 consist solely of a label when it is immediately followed
766 by a "}". */
771 }
775 }
777 }
782 }
786 }
792 }
806 }
811 {
812 /* -------------------------------------------------------------------- */
813 /* box <string-1> ... <string-n> -------------------------------------- */
814 /* -------------------------------------------------------------------- */
823 do
829 token_text);
836 }
837 else
841 }
842 }
845 }
861 /* -------------------------------------------------------------------- */
862 /* break -------------------------------------------------------------- */
863 /* -------------------------------------------------------------------- */
868 else
872 /* -------------------------------------------------------------------- */
873 /* continue ----------------------------------------------------------- */
874 /* -------------------------------------------------------------------- */
879 else
883 /* -------------------------------------------------------------------- */
884 /* do <codeblock> until (<condition>) --------------------------------- */
885 /* -------------------------------------------------------------------- */
900 }
906 /* -------------------------------------------------------------------- */
907 /* font on/off -------------------------------------------------------- */
908 /* -------------------------------------------------------------------- */
920 }
924 (for font off) or 1 (for font on). */
928 else
932 }
934 /* Set the fixed-pitch header bit. */
951 }
952 else
957 }
962 /* -------------------------------------------------------------------- */
963 /* for (<initialisation> : <continue-condition> : <updating>) --------- */
964 /* -------------------------------------------------------------------- */
966 /* Note that it's legal for any or all of the three sections of a
967 'for' specification to be empty. This 'for' implementation
968 often wastes 3 bytes with a redundant branch rather than keep
969 expression parse trees for long periods (as previous versions
970 of Inform did, somewhat crudely by simply storing the textual
971 form of a 'for' loop). It is adequate for now. */
977 /* Initialisation code */
986 }
999 }
1002 }
1005 }
1014 }
1017 ParseUpdate:
1025 }
1032 {
1036 /* The "finished yet?" condition */
1042 }
1044 }
1045 else
1046 {
1047 /* This is the jump which could be avoided with the aid
1048 of long-term expression storage */
1053 /* The "update" part */
1062 /* The "finished yet?" condition */
1068 }
1069 }
1072 {
1073 /* In this optimised case, update code is at the end
1074 of the loop block, so "continue" goes there */
1089 }
1090 else
1098 }
1100 }
1101 else
1102 {
1103 /* In the unoptimised case, update code is at the
1104 start of the loop block, so "continue" goes there */
1110 }
1111 }
1116 /* -------------------------------------------------------------------- */
1117 /* give <expression> [~]attr [, [~]attr [, ...]] ---------------------- */
1118 /* -------------------------------------------------------------------- */
1130 }
1132 do
1138 else
1142 token_text);
1145 }
1153 else
1154 {
1157 }
1158 }
1159 else
1163 /* -------------------------------------------------------------------- */
1164 /* if (<condition>) <codeblock> [else <codeblock>] -------------------- */
1165 /* -------------------------------------------------------------------- */
1178 else
1181 else
1184 }
1189 else
1195 }
1196 }
1207 }
1208 }
1209 }
1217 }
1221 /* -------------------------------------------------------------------- */
1222 /* inversion ---------------------------------------------------------- */
1223 /* -------------------------------------------------------------------- */
1247 /* -------------------------------------------------------------------- */
1248 /* jump <label> ------------------------------------------------------- */
1249 /* -------------------------------------------------------------------- */
1255 /* -------------------------------------------------------------------- */
1256 /* move <expression> to <expression> ---------------------------------- */
1257 /* -------------------------------------------------------------------- */
1270 }
1279 else
1282 }
1283 }
1284 else
1288 /* -------------------------------------------------------------------- */
1289 /* new_line ----------------------------------------------------------- */
1290 /* -------------------------------------------------------------------- */
1294 /* -------------------------------------------------------------------- */
1295 /* objectloop (<initialisation>) <codeblock> -------------------------- */
1296 /* -------------------------------------------------------------------- */
1304 else
1308 else
1311 }
1335 }
1339 implement objectloop (a in b) in the old way since
1340 this runs through objects in a different order from
1341 the new way, and there may be existing Inform code
1342 relying on this. */
1343 assembly_operand AO4;
1353 OBJECTLOOP_RTE);
1357 }
1363 CHILD_RTE);
1364 }
1367 }
1376 OBJECTLOOP2_RTE);
1391 }
1392 }
1397 }
1413 }
1426 /* -------------------------------------------------------------------- */
1427 /* (see routine above) ------------------------------------------------ */
1428 /* -------------------------------------------------------------------- */
1437 /* -------------------------------------------------------------------- */
1438 /* quit --------------------------------------------------------------- */
1439 /* -------------------------------------------------------------------- */
1443 /* -------------------------------------------------------------------- */
1444 /* read <expression> <expression> [<Routine>] ------------------------- */
1445 /* -------------------------------------------------------------------- */
1456 }
1463 else
1467 else
1469 /* Move the temp4 (buffer) value to the stack,
1470 since the routine might alter temp4. */
1478 else
1480 }
1481 }
1485 }
1489 /* -------------------------------------------------------------------- */
1490 /* remove <expression> ------------------------------------------------ */
1491 /* -------------------------------------------------------------------- */
1499 AO);
1500 else
1503 }
1504 }
1505 else
1509 /* -------------------------------------------------------------------- */
1510 /* restore <label> ---------------------------------------------------- */
1511 /* -------------------------------------------------------------------- */
1516 else
1521 }
1524 /* -------------------------------------------------------------------- */
1525 /* return [<expression>] ---------------------------------------------- */
1526 /* -------------------------------------------------------------------- */
1546 /* -------------------------------------------------------------------- */
1547 /* rfalse ------------------------------------------------------------- */
1548 /* -------------------------------------------------------------------- */
1552 /* -------------------------------------------------------------------- */
1553 /* rtrue -------------------------------------------------------------- */
1554 /* -------------------------------------------------------------------- */
1558 /* -------------------------------------------------------------------- */
1559 /* save <label> ------------------------------------------------------- */
1560 /* -------------------------------------------------------------------- */
1565 else
1569 }
1572 /* -------------------------------------------------------------------- */
1573 /* spaces <expression> ------------------------------------------------ */
1574 /* -------------------------------------------------------------------- */
1594 /* -------------------------------------------------------------------- */
1595 /* string <expression> <literal-string> ------------------------------- */
1596 /* -------------------------------------------------------------------- */
1610 }
1611 else
1614 }
1618 /* -------------------------------------------------------------------- */
1619 /* style roman/reverse/bold/underline/fixed --------------------------- */
1620 /* -------------------------------------------------------------------- */
1628 }
1641 token_text);
1644 }
1653 }
1656 /* -------------------------------------------------------------------- */
1657 /* switch (<expression>) <codeblock> ---------------------------------- */
1658 /* -------------------------------------------------------------------- */
1673 /* -------------------------------------------------------------------- */
1674 /* while (<condition>) <codeblock> ------------------------------------ */
1675 /* -------------------------------------------------------------------- */
1691 /* -------------------------------------------------------------------- */
1700 }
1702 StatementTerminator:
1708 }
1709 }
1723 {
1729 next_label++;
1730 }
1731 else
1737 }
1739 }
1745 }
1747 /* Interesting point of Inform grammar: a statement can only
1748 consist solely of a label when it is immediately followed
1749 by a "}". */
1754 }
1755 /* The following line prevents labels from influencing the positions
1756 of sequence points. */
1760 }
1762 }
1767 }
1771 }
1777 }
1791 }
1796 {
1798 /* -------------------------------------------------------------------- */
1799 /* box <string-1> ... <string-n> -------------------------------------- */
1800 /* -------------------------------------------------------------------- */
1807 do
1813 token_text);
1820 }
1821 else
1825 }
1826 }
1829 }
1842 /* -------------------------------------------------------------------- */
1843 /* break -------------------------------------------------------------- */
1844 /* -------------------------------------------------------------------- */
1849 else
1853 /* -------------------------------------------------------------------- */
1854 /* continue ----------------------------------------------------------- */
1855 /* -------------------------------------------------------------------- */
1860 else
1864 /* -------------------------------------------------------------------- */
1865 /* do <codeblock> until (<condition>) --------------------------------- */
1866 /* -------------------------------------------------------------------- */
1881 }
1887 /* -------------------------------------------------------------------- */
1888 /* font on/off -------------------------------------------------------- */
1889 /* -------------------------------------------------------------------- */
1901 }
1903 /* Call glk_set_style(normal or preformatted) */
1909 else
1915 /* -------------------------------------------------------------------- */
1916 /* for (<initialisation> : <continue-condition> : <updating>) --------- */
1917 /* -------------------------------------------------------------------- */
1919 /* Note that it's legal for any or all of the three sections of a
1920 'for' specification to be empty. This 'for' implementation
1921 often wastes 3 bytes with a redundant branch rather than keep
1922 expression parse trees for long periods (as previous versions
1923 of Inform did, somewhat crudely by simply storing the textual
1924 form of a 'for' loop). It is adequate for now. */
1930 /* Initialisation code */
1939 }
1952 }
1955 }
1958 }
1967 }
1970 ParseUpdate:
1978 }
1985 {
1989 /* The "finished yet?" condition */
1995 }
1997 }
1998 else
1999 {
2000 /* This is the jump which could be avoided with the aid
2001 of long-term expression storage */
2006 /* The "update" part */
2015 /* The "finished yet?" condition */
2021 }
2022 }
2025 {
2026 /* In this optimised case, update code is at the end
2027 of the loop block, so "continue" goes there */
2038 else
2042 }
2043 else
2047 else
2051 }
2053 }
2054 else
2055 {
2056 /* In the unoptimised case, update code is at the
2057 start of the loop block, so "continue" goes there */
2063 }
2064 }
2069 /* -------------------------------------------------------------------- */
2070 /* give <expression> [~]attr [, [~]attr [, ...]] ---------------------- */
2071 /* -------------------------------------------------------------------- */
2078 else
2081 do
2087 }
2089 }
2092 else
2096 token_text);
2099 }
2105 /* already on stack */
2106 }
2109 }
2112 else
2115 zero_operand);
2116 }
2121 }
2128 }
2132 stack_pointer);
2133 else
2135 stack_pointer);
2136 }
2139 else
2142 }
2145 /* -------------------------------------------------------------------- */
2146 /* if (<condition>) <codeblock> [else <codeblock>] -------------------- */
2147 /* -------------------------------------------------------------------- */
2160 else
2163 else
2166 }
2171 else
2177 }
2178 }
2189 }
2190 }
2191 }
2199 }
2203 /* -------------------------------------------------------------------- */
2204 /* inversion ---------------------------------------------------------- */
2205 /* -------------------------------------------------------------------- */
2249 }
2253 /* -------------------------------------------------------------------- */
2254 /* jump <label> ------------------------------------------------------- */
2255 /* -------------------------------------------------------------------- */
2261 /* -------------------------------------------------------------------- */
2262 /* move <expression> to <expression> ---------------------------------- */
2263 /* -------------------------------------------------------------------- */
2276 }
2283 zero_operand);
2284 else
2286 zero_operand);
2289 /* -------------------------------------------------------------------- */
2290 /* new_line ----------------------------------------------------------- */
2291 /* -------------------------------------------------------------------- */
2298 /* -------------------------------------------------------------------- */
2299 /* objectloop (<initialisation>) <codeblock> -------------------------- */
2300 /* -------------------------------------------------------------------- */
2310 }
2316 }
2321 }
2340 }
2343 /* Old style (Inform 5) objectloops: note that we
2344 implement objectloop (a in b) in the old way since
2345 this runs through objects in a different order from
2346 the new way, and there may be existing Inform code
2347 relying on this. */
2357 OBJECTLOOP_RTE);
2367 }
2372 CHILD_RTE);
2373 }
2379 }
2381 /* do nothing */
2382 }
2391 OBJECTLOOP2_RTE);
2404 next_label);
2409 }
2410 }
2413 }
2421 }
2440 }
2453 /* -------------------------------------------------------------------- */
2454 /* (see routine above) ------------------------------------------------ */
2455 /* -------------------------------------------------------------------- */
2464 /* -------------------------------------------------------------------- */
2465 /* quit --------------------------------------------------------------- */
2466 /* -------------------------------------------------------------------- */
2471 /* -------------------------------------------------------------------- */
2472 /* remove <expression> ------------------------------------------------ */
2473 /* -------------------------------------------------------------------- */
2480 zero_operand);
2481 else
2483 zero_operand);
2486 /* -------------------------------------------------------------------- */
2487 /* return [<expression>] ---------------------------------------------- */
2488 /* -------------------------------------------------------------------- */
2496 }
2503 /* -------------------------------------------------------------------- */
2504 /* rfalse ------------------------------------------------------------- */
2505 /* -------------------------------------------------------------------- */
2511 /* -------------------------------------------------------------------- */
2512 /* rtrue -------------------------------------------------------------- */
2513 /* -------------------------------------------------------------------- */
2519 /* -------------------------------------------------------------------- */
2520 /* spaces <expression> ------------------------------------------------ */
2521 /* -------------------------------------------------------------------- */
2540 /* -------------------------------------------------------------------- */
2541 /* string <expression> <literal-string> ------------------------------- */
2542 /* -------------------------------------------------------------------- */
2552 }
2553 else
2556 }
2561 /* -------------------------------------------------------------------- */
2562 /* style roman/reverse/bold/underline/fixed --------------------------- */
2563 /* -------------------------------------------------------------------- */
2577 token_text);
2580 }
2582 /* Call glk_set_style() */
2607 }
2612 /* -------------------------------------------------------------------- */
2613 /* switch (<expression>) <codeblock> ---------------------------------- */
2614 /* -------------------------------------------------------------------- */
2628 /* -------------------------------------------------------------------- */
2629 /* while (<condition>) <codeblock> ------------------------------------ */
2630 /* -------------------------------------------------------------------- */
2646 /* -------------------------------------------------------------------- */
2656 /* -------------------------------------------------------------------- */
2658 /* And a useful default, which will never be triggered in a complete
2659 Inform compiler, but which is important in development. */
2664 }
2666 StatementTerminator:
2672 }
2673 }
2676 {
2679 else
2681 }
2683 /* ========================================================================= */
2684 /* Data structure management routines */
2685 /* ------------------------------------------------------------------------- */
2688 {
2689 }
2692 {
2693 }
2696 {
2697 }
2700 {
2701 }
2703 /* ========================================================================= */