ch7bin.c 7.8 KB

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