expr.c 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318
  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. #ifndef NORCSID
  6. static char rcsid[]= "$Id$";
  7. #endif
  8. #include "assert.h"
  9. #include "param.h"
  10. #include "set.h"
  11. #include "reg.h"
  12. #include "lookup.h"
  13. #include "token.h"
  14. #include "property.h"
  15. #include "expr.h"
  16. #include "regvar.h"
  17. #include <cgg_cg.h>
  18. #include "extern.h"
  19. extern set_t l_sets[];
  20. i_expr(e) expr_t e; {
  21. if (e.ex_typ != TYPINT)
  22. error("Expression should be integer");
  23. return(e.ex_index);
  24. }
  25. b_expr(e) expr_t e; {
  26. if (e.ex_typ != TYPBOOL)
  27. error("Expression should be boolean");
  28. return(e.ex_index);
  29. }
  30. expr_t make_expr(type,operator,op1,op2) {
  31. expr_t result;
  32. result.ex_typ=type;
  33. result.ex_index=ex_lookup(operator,op1,op2);
  34. return(result);
  35. }
  36. expr_t regno_expr(regno) {
  37. expr_t result;
  38. register i;
  39. result.ex_typ = TYPREG;
  40. result.ex_index = ex_lookup(EX_REG,regno,0);
  41. for (i=0;i<SZOFSET(MAXREGS);i++)
  42. result.ex_regset[i] = 0;
  43. BIS(result.ex_regset,regno);
  44. return(result);
  45. }
  46. expr_t ident_expr(name) char *name; {
  47. register symbol *sy_p;
  48. sy_p = lookup(name,symany,mustexist);
  49. if (sy_p->sy_type==symconst)
  50. return(make_expr(TYPINT,EX_CON,
  51. (int) (sy_p->sy_value.syv_cstval&0xFFFF),
  52. (int) (sy_p->sy_value.syv_cstval>>16)));
  53. else if (sy_p->sy_type==symsconst)
  54. return(make_expr(TYPADDR,EX_STRING,sy_p->sy_value.syv_stringno,0));
  55. else if (sy_p->sy_type!=symreg)
  56. error("Wrong type of identifier %s",name);
  57. return(regno_expr(sy_p->sy_value.syv_regno));
  58. }
  59. expr_t subreg_expr(tokarg,subreg) {
  60. expr_t result;
  61. result.ex_typ = TYPREG;
  62. subregset(l_sets[tokpatset[tokarg > 0 ? tokarg-1 : tokarg]].set_val,
  63. subreg,result.ex_regset);
  64. result.ex_index = ex_lookup(EX_SUBREG,tokarg,subreg);
  65. return(result);
  66. }
  67. subregset(sp,subreg,regset) register short *sp; register short *regset; {
  68. register i;
  69. register reginfo *rp;
  70. for (i=0;i<SZOFSET(MAXREGS);i++)
  71. regset[i]=0;
  72. for (i=1;i<nregs;i++) if (BIT(sp,i)) {
  73. if(subreg) {
  74. rp = &l_regs[i];
  75. if (rp->ri_memb[subreg-1]==0)
  76. error("Register %s in set has no member %d",
  77. rp->ri_name,subreg);
  78. BIS(regset,rp->ri_memb[subreg-1]);
  79. } else
  80. BIS(regset,i);
  81. }
  82. for(;i<nregs+MAXTOKENS;i++) if(BIT(sp,i))
  83. error("Set contains %s, which is not a register",
  84. l_tokens[i-nregs]->tk_name);
  85. }
  86. membset(setno,name,regset,appearance,restyp,typp)
  87. char *name,*appearance;
  88. short *regset;
  89. int *typp;
  90. {
  91. register short *sp;
  92. register token_p tp;
  93. register i,j,k;
  94. int thistyp;
  95. int typesdiffer=0;
  96. int res_j= -1;
  97. if (setno < 0) return 0;
  98. sp = l_sets[setno].set_val;
  99. for (i=1;i<nregs;i++) if (BIT(sp,i)) {
  100. error("Set in %s contains %s, which is not a token",
  101. appearance,l_regs[i].ri_name);
  102. break;
  103. }
  104. for (i=0;i<SZOFSET(MAXREGS);i++)
  105. regset[i] = 0;
  106. for (i=nregs;i<nregs+MAXTOKENS;i++) if (BIT(sp,i)) {
  107. tp = l_tokens[i-nregs];
  108. for(j=0;j<MAXATT &&
  109. (tp->tk_att[j].ta_type == -3 ||
  110. strcmp(tp->tk_att[j].ta_name,name));j++)
  111. ;
  112. if (j==MAXATT)
  113. error("Token %s does not contain %s",tp->tk_name,name);
  114. else if (j!=res_j && res_j != -1)
  115. typesdiffer=1;
  116. else {
  117. res_j = j;
  118. thistyp = tp->tk_att[j].ta_type;
  119. if (thistyp== -2) {
  120. if (restyp!=TYPADDR && restyp!=0)
  121. typesdiffer=1;
  122. else
  123. restyp=TYPADDR;
  124. } else if (thistyp== -1) {
  125. if (restyp!=TYPINT && restyp!=0)
  126. typesdiffer=1;
  127. else
  128. restyp=TYPINT;
  129. } else {
  130. if (restyp!=TYPREG && restyp!=0)
  131. typesdiffer=1;
  132. else {
  133. restyp=TYPREG;
  134. for(k=0;k<SZOFSET(MAXREGS);k++)
  135. regset[k] |=
  136. l_props[tp->tk_att[j].ta_type].pr_regset[k];
  137. }
  138. }
  139. }
  140. }
  141. if (typesdiffer)
  142. error("%s is not a valid expression; types differ in the set",
  143. appearance);
  144. *typp = restyp==0 ? TYPINT : restyp;
  145. return(res_j == -1 ? 0 : res_j);
  146. }
  147. expr_t memb_expr(setno,name,appearance,tokarg) char *name,*appearance; {
  148. expr_t result;
  149. int res_j;
  150. res_j = membset(setno,name,result.ex_regset,appearance,0,&result.ex_typ);
  151. result.ex_index = ex_lookup(EX_TOKFIELD,tokarg,res_j+1);
  152. return(result);
  153. }
  154. expr_t tokm_expr(tokarg,name) char *name; {
  155. char app[100];
  156. int tokarg1 = tokarg > 0 ? tokarg : 1;
  157. sprintf(app,"%%%d.%s",tokarg1,name);
  158. return(memb_expr(tokpatset[tokarg1-1],name,app,tokarg));
  159. }
  160. expr_t perc_ident_expr(name) char *name; {
  161. char app[100];
  162. sprintf(app,"%%%s",name);
  163. return(memb_expr(cursetno,name,app,0));
  164. }
  165. expr_t all_expr(all_no,subreg) {
  166. set_t localset;
  167. register i;
  168. register short *sp;
  169. expr_t result;
  170. sp = l_props[allreg[all_no]].pr_regset;
  171. for (i=0;i<SETSIZE;i++)
  172. localset.set_val[i] = i<SZOFSET(MAXREGS) ? sp[i] : 0;
  173. subregset(localset.set_val,subreg,result.ex_regset);
  174. result.ex_typ = TYPREG;
  175. result.ex_index = ex_lookup(EX_ALLREG,all_no+1,subreg);
  176. return(result);
  177. }
  178. eq2expr(e1,e2) expr_t e1,e2; {
  179. if (e1.ex_typ != e2.ex_typ)
  180. error("Expressions around == should have equal type");
  181. switch (e1.ex_typ) {
  182. default: assert(0);
  183. case TYPBOOL:
  184. error("== on booleans not implemented");
  185. case TYPINT:
  186. return(EX_NCPEQ);
  187. case TYPADDR:
  188. return(EX_SCPEQ);
  189. case TYPREG:
  190. return(EX_RCPEQ);
  191. }
  192. }
  193. ne2expr(e1,e2) expr_t e1,e2; {
  194. if (e1.ex_typ != e2.ex_typ)
  195. error("Expressions around != should have equal type");
  196. switch (e1.ex_typ) {
  197. default: assert(0);
  198. case TYPBOOL:
  199. error("!= on booleans not implemented");
  200. case TYPINT:
  201. return(EX_NCPNE);
  202. case TYPADDR:
  203. return(EX_SCPNE);
  204. case TYPREG:
  205. return(EX_RCPNE);
  206. }
  207. }
  208. expr_t sum_expr(e1,e2) expr_t e1,e2; {
  209. int operator,op1,op2;
  210. expr_t result;
  211. operator = EX_CAT; op1 = e1.ex_index; op2 = e2.ex_index;
  212. if (e1.ex_typ==e2.ex_typ) {
  213. result.ex_typ = e1.ex_typ;
  214. if (e1.ex_typ == TYPINT)
  215. operator = EX_PLUS;
  216. else if (e1.ex_typ != TYPADDR)
  217. error("+ is not implemented on this type");
  218. } else {
  219. result.ex_typ = TYPADDR;
  220. if (e1.ex_typ != TYPADDR) {
  221. if (e1.ex_typ!=TYPINT)
  222. error("Wrong left operand of +");
  223. op1 = ex_lookup(EX_TOSTRING,op1,0);
  224. }
  225. if (e2.ex_typ != TYPADDR) {
  226. if (e2.ex_typ!=TYPINT)
  227. error("Wrong right operand of +");
  228. op2 = ex_lookup(EX_TOSTRING,op2,0);
  229. }
  230. }
  231. result.ex_index=ex_lookup(operator,op1,op2);
  232. return(result);
  233. }
  234. expr_t iextoaddr(e) expr_t e; {
  235. expr_t result;
  236. result.ex_typ = TYPADDR;
  237. result.ex_index = ex_lookup(EX_TOSTRING,e.ex_index,0);
  238. return(result);
  239. }
  240. expr_t regvar_expr(e,regtyp) expr_t e; {
  241. expr_t result;
  242. register i;
  243. result = make_expr(TYPREG,EX_REGVAR,i_expr(e),0);
  244. for(i=0;i<SZOFSET(MAXREGS);i++)
  245. result.ex_regset[i]=0;
  246. for(i=0;i<nregvar[regtyp];i++)
  247. BIS(result.ex_regset,rvnumbers[regtyp][i]);
  248. return(result);
  249. }
  250. /*
  251. * Node table lookup part
  252. */
  253. node_t nodes[MAXNODES];
  254. int nnodes=0;
  255. initnodes() {
  256. nodes[0].ex_operator = EX_CON;
  257. nodes[0].ex_lnode = 0;
  258. nodes[0].ex_rnode = 0;
  259. nnodes++;
  260. }
  261. ex_lookup(operator,lnode,rnode) {
  262. register node_p p;
  263. for(p=nodes+1;p< &nodes[nnodes];p++) {
  264. if (p->ex_operator != operator)
  265. continue;
  266. if (p->ex_lnode != lnode)
  267. continue;
  268. if (p->ex_rnode != rnode)
  269. continue;
  270. return(p-nodes);
  271. }
  272. NEXT(nnodes,MAXNODES,"Node");
  273. p->ex_operator = operator;
  274. p->ex_lnode = lnode;
  275. p->ex_rnode = rnode;
  276. return(p-nodes);
  277. }