expr.c 7.0 KB

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