ch7bin.c 7.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308
  1. /* $Header$ */
  2. /* SEMANTIC ANALYSIS (CHAPTER 7RM) -- BINARY OPERATORS */
  3. #include "botch_free.h" /* UF */
  4. #include "idf.h"
  5. #include "arith.h"
  6. #include "type.h"
  7. #include "struct.h"
  8. #include "label.h"
  9. #include "expr.h"
  10. #include "Lpars.h"
  11. #include "storage.h"
  12. extern char options[];
  13. extern char *symbol2str();
  14. /* This chapter asks for the repeated application of code to handle
  15. an operation that may be executed at compile time or at run time,
  16. depending on the constancy of the operands.
  17. */
  18. ch7bin(expp, oper, expr)
  19. register struct expr **expp;
  20. struct expr *expr;
  21. {
  22. /* apply binary operator oper between *expp and expr.
  23. */
  24. any2opnd(expp, oper);
  25. any2opnd(&expr, oper);
  26. switch (oper) {
  27. int fund;
  28. case '[': /* RM 7.1 */
  29. /* RM 14.3 states that indexing follows the commutative laws */
  30. switch ((*expp)->ex_type->tp_fund) {
  31. case POINTER:
  32. case ARRAY:
  33. break;
  34. case ERRONEOUS:
  35. return;
  36. default: /* unindexable */
  37. switch (expr->ex_type->tp_fund) {
  38. case POINTER:
  39. case ARRAY:
  40. break;
  41. case ERRONEOUS:
  42. return;
  43. default:
  44. error("indexing an object of type %s",
  45. symbol2str((*expp)->ex_type->tp_fund));
  46. return;
  47. }
  48. break;
  49. }
  50. ch7bin(expp, '+', expr);
  51. ch7mon('*', expp);
  52. break;
  53. case '(': /* RM 7.1 */
  54. if ( (*expp)->ex_type->tp_fund == POINTER &&
  55. (*expp)->ex_type->tp_up->tp_fund == FUNCTION
  56. ) {
  57. if (options['R'])
  58. warning("function pointer called");
  59. ch7mon('*', expp);
  60. }
  61. if ((*expp)->ex_type->tp_fund != FUNCTION) {
  62. if ((*expp)->ex_type != error_type)
  63. error("call of non-function (%s)",
  64. symbol2str((*expp)->ex_type->tp_fund));
  65. /* leave the expression; it may still serve */
  66. free_expression(expr); /* there go the parameters */
  67. }
  68. else
  69. *expp = new_oper((*expp)->ex_type->tp_up,
  70. *expp, '(', expr);
  71. break;
  72. case PARCOMMA: /* RM 7.1 */
  73. if ((*expp)->ex_type->tp_fund == FUNCTION)
  74. function2pointer(expp);
  75. *expp = new_oper(expr->ex_type, *expp, PARCOMMA, expr);
  76. break;
  77. case '%':
  78. fund = arithbalance(expp, oper, &expr);
  79. if (fund == DOUBLE) {
  80. error("floating operand to %%");
  81. *expp = intexpr((arith)1, INT);
  82. }
  83. else
  84. non_commutative_binop(expp, oper, expr);
  85. break;
  86. case '/':
  87. fund = arithbalance(expp, oper, &expr);
  88. non_commutative_binop(expp, oper, expr);
  89. break;
  90. case '*':
  91. fund = arithbalance(expp, oper, &expr);
  92. commutative_binop(expp, oper, expr);
  93. break;
  94. case '+':
  95. if (expr->ex_type->tp_fund == POINTER) {
  96. /* swap operands */
  97. struct expr *etmp = expr;
  98. expr = *expp;
  99. *expp = etmp;
  100. }
  101. if ((*expp)->ex_type->tp_fund == POINTER) {
  102. pointer_arithmetic(expp, oper, &expr);
  103. if (expr->ex_type->tp_size != (*expp)->ex_type->tp_size)
  104. ch7cast(&expr, CAST, (*expp)->ex_type);
  105. pointer_binary(expp, oper, expr);
  106. }
  107. else {
  108. fund = arithbalance(expp, oper, &expr);
  109. commutative_binop(expp, oper, expr);
  110. }
  111. break;
  112. case '-':
  113. if ((*expp)->ex_type->tp_fund == POINTER) {
  114. if (expr->ex_type->tp_fund == POINTER)
  115. pntminuspnt(expp, oper, expr);
  116. else {
  117. pointer_arithmetic(expp, oper, &expr);
  118. pointer_binary(expp, oper, expr);
  119. }
  120. }
  121. else {
  122. fund = arithbalance(expp, oper, &expr);
  123. non_commutative_binop(expp, oper, expr);
  124. }
  125. break;
  126. case LEFT:
  127. case RIGHT:
  128. opnd2integral(expp, oper);
  129. opnd2integral(&expr, oper);
  130. ch7cast(&expr, oper, int_type); /* leftop should be int */
  131. non_commutative_binop(expp, oper, expr);
  132. break;
  133. case '<':
  134. case '>':
  135. case LESSEQ:
  136. case GREATEREQ:
  137. case EQUAL:
  138. case NOTEQUAL:
  139. relbalance(expp, oper, &expr);
  140. non_commutative_binop(expp, oper, expr);
  141. (*expp)->ex_type = int_type;
  142. break;
  143. case '&':
  144. case '^':
  145. case '|':
  146. opnd2integral(expp, oper);
  147. opnd2integral(&expr, oper);
  148. fund = arithbalance(expp, oper, &expr); /* <=== */
  149. commutative_binop(expp, oper, expr);
  150. break;
  151. case AND:
  152. case OR:
  153. opnd2test(expp, oper);
  154. opnd2test(&expr, oper);
  155. if (is_cp_cst(*expp)) {
  156. struct expr *ex = *expp;
  157. /* the following condition is a short-hand for
  158. ((oper == AND) && o1) || ((oper == OR) && !o1)
  159. where o1 == (*expp)->VL_VALUE;
  160. and ((oper == AND) || (oper == OR))
  161. */
  162. if ((oper == AND) == ((*expp)->VL_VALUE != (arith)0))
  163. *expp = expr;
  164. else {
  165. free_expression(expr);
  166. *expp = intexpr((arith)((oper == AND) ? 0 : 1),
  167. INT);
  168. }
  169. free_expression(ex);
  170. }
  171. else
  172. if (is_cp_cst(expr)) {
  173. /* Note!!!: the following condition is a short-hand for
  174. ((oper == AND) && o2) || ((oper == OR) && !o2)
  175. where o2 == expr->VL_VALUE
  176. and ((oper == AND) || (oper == OR))
  177. */
  178. if ((oper == AND) == (expr->VL_VALUE != (arith)0))
  179. free_expression(expr);
  180. else {
  181. if (oper == OR)
  182. expr->VL_VALUE = (arith)1;
  183. ch7bin(expp, ',', expr);
  184. }
  185. }
  186. else
  187. *expp = new_oper(int_type, *expp, oper, expr);
  188. (*expp)->ex_flags |= EX_LOGICAL;
  189. break;
  190. case ':':
  191. if ( is_struct_or_union((*expp)->ex_type->tp_fund)
  192. || is_struct_or_union(expr->ex_type->tp_fund)
  193. ) {
  194. if ((*expp)->ex_type != expr->ex_type) {
  195. error("illegal balance");
  196. (*expp)->ex_type = error_type;
  197. }
  198. }
  199. else {
  200. relbalance(expp, oper, &expr);
  201. }
  202. *expp = new_oper((*expp)->ex_type, *expp, oper, expr);
  203. break;
  204. case '?':
  205. opnd2logical(expp, oper);
  206. if (is_cp_cst(*expp))
  207. *expp = (*expp)->VL_VALUE ?
  208. expr->OP_LEFT : expr->OP_RIGHT;
  209. else
  210. *expp = new_oper(expr->ex_type, *expp, oper, expr);
  211. break;
  212. case ',':
  213. if (is_cp_cst(*expp))
  214. *expp = expr;
  215. else
  216. *expp = new_oper(expr->ex_type, *expp, oper, expr);
  217. (*expp)->ex_flags |= EX_COMMA;
  218. break;
  219. }
  220. }
  221. pntminuspnt(expp, oper, expr)
  222. register struct expr **expp, *expr;
  223. {
  224. /* Subtracting two pointers is so complicated it merits a
  225. routine of its own.
  226. */
  227. struct type *up_type = (*expp)->ex_type->tp_up;
  228. if (up_type != expr->ex_type->tp_up) {
  229. error("subtracting incompatible pointers");
  230. free_expression(expr);
  231. free_expression(*expp);
  232. *expp = intexpr((arith)0, INT);
  233. return;
  234. }
  235. /* we hope the optimizer will eliminate the load-time
  236. pointer subtraction
  237. */
  238. *expp = new_oper((*expp)->ex_type, *expp, oper, expr);
  239. ch7cast(expp, CAST, pa_type); /* ptr-ptr: result has pa_type */
  240. ch7bin(expp, '/',
  241. intexpr(size_of_type(up_type, "object"), pa_type->tp_fund));
  242. ch7cast(expp, CAST, int_type); /* result will be an integer expr */
  243. }
  244. non_commutative_binop(expp, oper, expr)
  245. register struct expr **expp, *expr;
  246. {
  247. /* Constructs in *expp the operation indicated by the operands.
  248. "oper" is a non-commutative operator
  249. */
  250. if (is_cp_cst(expr) && is_cp_cst(*expp))
  251. cstbin(expp, oper, expr);
  252. else
  253. *expp = new_oper((*expp)->ex_type, *expp, oper, expr);
  254. }
  255. commutative_binop(expp, oper, expr)
  256. register struct expr **expp, *expr;
  257. {
  258. /* Constructs in *expp the operation indicated by the operands.
  259. "oper" is a commutative operator
  260. */
  261. if (is_cp_cst(expr) && is_cp_cst(*expp))
  262. cstbin(expp, oper, expr);
  263. else
  264. if ((*expp)->ex_depth > expr->ex_depth)
  265. *expp = new_oper((*expp)->ex_type, *expp, oper, expr);
  266. else
  267. *expp = new_oper((*expp)->ex_type, expr, oper, *expp);
  268. }
  269. pointer_arithmetic(expp1, oper, expp2)
  270. register struct expr **expp1, **expp2;
  271. {
  272. /* prepares the integral expression expp2 in order to
  273. apply it to the pointer expression expp1
  274. */
  275. if (any2arith(expp2, oper) == DOUBLE) {
  276. expr_error(*expp2,
  277. "illegal combination of float and pointer");
  278. free_expression(*expp2);
  279. *expp2 = intexpr((arith)0, INT);
  280. }
  281. ch7bin( expp2, '*',
  282. intexpr(size_of_type((*expp1)->ex_type->tp_up, "object"),
  283. pa_type->tp_fund)
  284. );
  285. }
  286. pointer_binary(expp, oper, expr)
  287. register struct expr **expp, *expr;
  288. {
  289. /* constructs the pointer arithmetic expression out of
  290. a pointer expression, a binary operator and an integral
  291. expression.
  292. */
  293. if (is_ld_cst(expr) && is_ld_cst(*expp))
  294. cstbin(expp, oper, expr);
  295. else
  296. *expp = new_oper((*expp)->ex_type, *expp, oper, expr);
  297. }