expr.c 6.7 KB

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