expr.c 7.1 KB

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