statement.g 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390
  1. /*
  2. * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  3. * See the copyright notice in the ACK home directory, in the file "Copyright".
  4. */
  5. /* $Header$ */
  6. /* STATEMENT SYNTAX PARSER */
  7. {
  8. #include <em.h>
  9. #include "debug.h"
  10. #include "botch_free.h"
  11. #include "arith.h"
  12. #include "LLlex.h"
  13. #include "type.h"
  14. #include "idf.h"
  15. #include "label.h"
  16. #include "expr.h"
  17. #include "code.h"
  18. #include "stack.h"
  19. #include "def.h"
  20. extern int level;
  21. }
  22. /* Each statement construction is stacked in order to trace a
  23. statement to such a construction. Example: a case statement should
  24. be recognized as a piece of the most enclosing switch statement.
  25. */
  26. /* 9 */
  27. statement
  28. :
  29. %if (AHEAD != ':')
  30. expression_statement
  31. |
  32. label ':' statement
  33. |
  34. compound_statement((arith *)0)
  35. |
  36. if_statement
  37. |
  38. while_statement
  39. |
  40. do_statement
  41. |
  42. for_statement
  43. |
  44. switch_statement
  45. |
  46. case_statement
  47. |
  48. default_statement
  49. |
  50. BREAK
  51. {code_break();}
  52. ';'
  53. |
  54. CONTINUE
  55. {code_continue();}
  56. ';'
  57. |
  58. return_statement
  59. |
  60. jump
  61. |
  62. ';'
  63. |
  64. asm_statement
  65. ;
  66. expression_statement
  67. { struct expr *expr;
  68. }
  69. :
  70. expression(&expr)
  71. ';'
  72. {
  73. #ifdef DEBUG
  74. print_expr("Full expression", expr);
  75. #endif DEBUG
  76. code_expr(expr, RVAL, FALSE, NO_LABEL, NO_LABEL);
  77. free_expression(expr);
  78. }
  79. ;
  80. label
  81. { struct idf *idf;
  82. }
  83. :
  84. identifier(&idf)
  85. {
  86. /* This allows the following absurd case:
  87. typedef int grz;
  88. main() {
  89. grz: printf("A labelled statement\n");
  90. }
  91. */
  92. define_label(idf);
  93. C_df_ilb((label)idf->id_def->df_address);
  94. }
  95. ;
  96. if_statement
  97. {
  98. struct expr *expr;
  99. label l_true = text_label();
  100. label l_false = text_label();
  101. label l_end = text_label();
  102. }
  103. :
  104. IF
  105. '('
  106. expression(&expr)
  107. {
  108. opnd2test(&expr, IF);
  109. if (is_cp_cst(expr)) {
  110. /* The comparison has been optimized
  111. to a 0 or 1.
  112. */
  113. if (expr->VL_VALUE == (arith)0) {
  114. C_bra(l_false);
  115. }
  116. /* else fall through */
  117. }
  118. else {
  119. code_expr(expr, RVAL, TRUE, l_true, l_false);
  120. C_df_ilb(l_true);
  121. }
  122. free_expression(expr);
  123. }
  124. ')'
  125. statement
  126. [%prefer
  127. ELSE
  128. {
  129. C_bra(l_end);
  130. C_df_ilb(l_false);
  131. }
  132. statement
  133. { C_df_ilb(l_end);
  134. }
  135. |
  136. empty
  137. { C_df_ilb(l_false);
  138. }
  139. ]
  140. ;
  141. while_statement
  142. {
  143. struct expr *expr;
  144. label l_break = text_label();
  145. label l_continue = text_label();
  146. label l_body = text_label();
  147. }
  148. :
  149. WHILE
  150. {
  151. stack_stmt(l_break, l_continue);
  152. C_df_ilb(l_continue);
  153. }
  154. '('
  155. expression(&expr)
  156. {
  157. opnd2test(&expr, WHILE);
  158. if (is_cp_cst(expr)) {
  159. if (expr->VL_VALUE == (arith)0) {
  160. C_bra(l_break);
  161. }
  162. }
  163. else {
  164. code_expr(expr, RVAL, TRUE, l_body, l_break);
  165. C_df_ilb(l_body);
  166. }
  167. }
  168. ')'
  169. statement
  170. {
  171. C_bra(l_continue);
  172. C_df_ilb(l_break);
  173. unstack_stmt();
  174. free_expression(expr);
  175. }
  176. ;
  177. do_statement
  178. { struct expr *expr;
  179. label l_break = text_label();
  180. label l_continue = text_label();
  181. label l_body = text_label();
  182. }
  183. :
  184. DO
  185. { C_df_ilb(l_body);
  186. stack_stmt(l_break, l_continue);
  187. }
  188. statement
  189. WHILE
  190. '('
  191. { C_df_ilb(l_continue);
  192. }
  193. expression(&expr)
  194. {
  195. opnd2test(&expr, WHILE);
  196. if (is_cp_cst(expr)) {
  197. if (expr->VL_VALUE == (arith)1) {
  198. C_bra(l_body);
  199. }
  200. }
  201. else {
  202. code_expr(expr, RVAL, TRUE, l_body, l_break);
  203. }
  204. C_df_ilb(l_break);
  205. }
  206. ')'
  207. ';'
  208. {
  209. unstack_stmt();
  210. free_expression(expr);
  211. }
  212. ;
  213. for_statement
  214. { struct expr *e_init = 0, *e_test = 0, *e_incr = 0;
  215. label l_break = text_label();
  216. label l_continue = text_label();
  217. label l_body = text_label();
  218. label l_test = text_label();
  219. }
  220. :
  221. FOR
  222. { stack_stmt(l_break, l_continue);
  223. }
  224. '('
  225. [
  226. expression(&e_init)
  227. { code_expr(e_init, RVAL, FALSE, NO_LABEL, NO_LABEL);
  228. }
  229. ]?
  230. ';'
  231. { C_df_ilb(l_test);
  232. }
  233. [
  234. expression(&e_test)
  235. {
  236. opnd2test(&e_test, FOR);
  237. if (is_cp_cst(e_test)) {
  238. if (e_test->VL_VALUE == (arith)0) {
  239. C_bra(l_break);
  240. }
  241. }
  242. else {
  243. code_expr(e_test, RVAL, TRUE, l_body, l_break);
  244. C_df_ilb(l_body);
  245. }
  246. }
  247. ]?
  248. ';'
  249. expression(&e_incr)?
  250. ')'
  251. statement
  252. {
  253. C_df_ilb(l_continue);
  254. if (e_incr)
  255. code_expr(e_incr, RVAL, FALSE,
  256. NO_LABEL, NO_LABEL);
  257. C_bra(l_test);
  258. C_df_ilb(l_break);
  259. unstack_stmt();
  260. free_expression(e_init);
  261. free_expression(e_test);
  262. free_expression(e_incr);
  263. }
  264. ;
  265. switch_statement
  266. {
  267. struct expr *expr;
  268. }
  269. :
  270. SWITCH
  271. '('
  272. expression(&expr)
  273. {
  274. code_startswitch(&expr);
  275. }
  276. ')'
  277. statement
  278. {
  279. code_endswitch();
  280. free_expression(expr);
  281. }
  282. ;
  283. case_statement
  284. {
  285. struct expr *expr;
  286. }
  287. :
  288. CASE
  289. constant_expression(&expr)
  290. {
  291. code_case(expr);
  292. free_expression(expr);
  293. }
  294. ':'
  295. statement
  296. ;
  297. default_statement
  298. :
  299. DEFAULT
  300. {
  301. code_default();
  302. }
  303. ':'
  304. statement
  305. ;
  306. return_statement
  307. { struct expr *expr = 0;
  308. }
  309. :
  310. RETURN
  311. [
  312. expression(&expr)
  313. {
  314. do_return_expr(expr);
  315. free_expression(expr);
  316. }
  317. |
  318. empty
  319. {
  320. do_return();
  321. }
  322. ]
  323. ';'
  324. ;
  325. jump
  326. { struct idf *idf;
  327. }
  328. :
  329. GOTO
  330. identifier(&idf)
  331. ';'
  332. {
  333. apply_label(idf);
  334. C_bra((label)idf->id_def->df_address);
  335. }
  336. ;
  337. compound_statement(arith *nbytes;):
  338. '{'
  339. {
  340. stack_level();
  341. }
  342. [%while (AHEAD != ':') /* >>> conflict on TYPE_IDENTIFIER */
  343. declaration
  344. ]*
  345. [%persistent
  346. statement
  347. ]*
  348. '}'
  349. {
  350. if (nbytes)
  351. *nbytes = (- local_level->sl_max_block);
  352. unstack_level();
  353. }
  354. ;
  355. asm_statement
  356. { char *asm_bts;
  357. int asm_len;
  358. }
  359. :
  360. ASM
  361. '('
  362. STRING
  363. { asm_bts = dot.tk_bts;
  364. asm_len = dot.tk_len;
  365. }
  366. ')'
  367. ';'
  368. { code_asm(asm_bts, asm_len);
  369. }
  370. ;