statement.g 5.4 KB

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