statement.g 5.2 KB

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