home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / prog_c / zc.lzh / ZC / ZCSRC.LZH / src / md.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-06-07  |  7.4 KB  |  460 lines
  1. /* Copyright (c) 1988 by Sozobon, Limited.  Author: Johann Ruegg
  2.  *
  3.  * Permission is granted to anyone to use this software for any purpose
  4.  * on any computer system, and to redistribute it freely, with the
  5.  * following restrictions:
  6.  * 1) No charge may be made other than reasonable charges for reproduction.
  7.  * 2) Modified versions must be clearly marked as such.
  8.  * 3) The authors are not responsible for any harmful consequences
  9.  *    of using this software, even if they result from defects in it.
  10.  *
  11.  *    md.c
  12.  *
  13.  *    Machine dependant parts of first pass (parse)
  14.  *    Also type checking subroutines.
  15.  */
  16.  
  17. /*
  18.  * Changes for Amiga version by Jeff Lydiatt marked by "Jal".
  19.  */
  20.  
  21. #include <stdio.h>
  22. #include "param.h"
  23. #include "tok.h"
  24. #include "nodes.h"
  25. #include "cookie.h"
  26.  
  27. NODEP bas_type();
  28.  
  29. int adjtab[] = {
  30.     K_INT,        /* none */
  31.     K_SHORT,    /* short */
  32.     K_LONG,     /* long */
  33.     0,        /* short long */
  34. #if SIZE_I == 2
  35.     K_UNSIGNED,    /* unsigned */
  36. #else
  37.     T_ULONG,    /* unsigned long */
  38. #endif
  39.     K_UNSIGNED,    /* unsigned short */
  40.     T_ULONG,    /* unsigned long */
  41.     0,        /* unsigned short long */
  42. };
  43.  
  44. adj_type(old, adj)
  45. {
  46.     int rv;
  47.  
  48.     switch (old) {
  49.     case K_CHAR:
  50.         if (adj & SAW_UNS)
  51.             return T_UCHAR;
  52.         break;
  53.     case K_INT:
  54.         rv = adjtab[adj];
  55.         if (rv == 0) {
  56.             error("bad type spec");
  57.             return K_INT;
  58.         }
  59.         return rv;
  60.     case K_FLOAT:
  61.         if (adj & SAW_LONG)
  62.             return K_DOUBLE;
  63.         break;
  64.     }
  65.     return old;
  66. }
  67.  
  68. /* given ICON value, and flags SEE_L,SEE_U
  69.     determine final type */
  70. icon_ty(tp)
  71. NODE *tp;
  72. {
  73.     int flags;
  74.     long val;
  75.     int islong, isuns;
  76.  
  77.     flags = tp->e_flags;
  78.     val = tp->e_ival;
  79.  
  80.     islong = (flags & SEE_L);
  81.     isuns = (flags & SEE_U);
  82.  
  83.     if (islong && isuns)
  84.         return T_ULONG;
  85.     if (islong || islongv(val))
  86.         return K_LONG;
  87.     if (isuns)
  88.         return K_UNSIGNED;
  89.     return isintv((int)val) ? K_INT : K_CHAR;
  90. }
  91.  
  92. isintv(i)
  93. {
  94.     if (i > 0x7f || i < -0x80)
  95.         return 1;
  96.     return 0;
  97. }
  98.  
  99. islongv(l)
  100. long l;
  101. {
  102. #ifndef NOLONGS
  103.     if (l > MAXUNS || l < MININT)
  104.         return 1;
  105. #endif
  106.     return 0;
  107. }
  108.  
  109. mkint(l)
  110. long l;
  111. {
  112.     return l;
  113. }
  114.  
  115. lc_reg(rp, xp)
  116. int *rp;
  117. NODE *xp;
  118. {
  119.     switch (xp->n_tptr->t_token) {
  120.     case STAR:
  121.         return al_areg(rp,xp);
  122.     case K_CHAR:
  123.     case T_UCHAR:
  124.     case T_ULONG:
  125.     case K_INT:
  126.     case K_UNSIGNED:
  127.     case K_LONG:
  128.         return al_dreg(rp,xp);
  129.     default:
  130.         return 0;
  131.     }
  132. }
  133.  
  134. al_areg(rp,xp)
  135. int *rp;
  136. NODEP xp;
  137. {
  138.     register rmask, n;
  139.  
  140.     rmask = *rp;
  141.     for (n=ARV_START; n<=ARV_END; n++)
  142.         if ((rmask & (1<<n)) == 0) {
  143.             xp->e_rno = n;
  144.             *rp |= (1<<n);
  145.             return 1;
  146.         }
  147.     return 0;
  148. }
  149.  
  150. al_dreg(rp,xp)
  151. int *rp;
  152. NODEP xp;
  153. {
  154.     register rmask, n;
  155.  
  156.     rmask = *rp;
  157.     for (n=DRV_START; n<=DRV_END; n++)
  158.         if ((rmask & (1<<n)) == 0) {
  159.             xp->e_rno = n;
  160.             *rp |= (1<<n);
  161.             return 1;
  162.         }
  163.     return 0;
  164. }
  165.  
  166. long
  167. arg_size(sz,np)
  168. long sz;
  169. NODEP np;
  170. {
  171.     np->e_offs = 0;
  172.  
  173.     switch (np->n_tptr->t_token) {
  174.     case '[':
  175.         printf("GAK! array arg ");
  176.         return SIZE_P;
  177.     case K_CHAR:
  178.     case T_UCHAR:
  179.         np->e_offs = SIZE_I - SIZE_C;
  180.         return SIZE_I;
  181. #if SIZE_I != SIZE_S
  182.     case K_SHORT:
  183.         np->e_offs = SIZE_I - SIZE_S;
  184.         return SIZE_I;
  185. #endif
  186.     default:
  187.         return sz;
  188.     }
  189. }
  190.  
  191. mustlval(np)
  192. NODEP np;
  193. {
  194.     switch (np->e_token) {
  195.     case ID:
  196.     case STAR:
  197.     case '.':
  198.         break;
  199.     default:
  200.         errorn("not lvalue", np);
  201.         return 1;
  202.     }
  203.     return 0;
  204. }
  205.  
  206. mustty(np, flags)
  207. NODEP np;
  208. {
  209.     switch (np->n_tptr->t_token) {
  210.     case STAR:
  211.         if (flags & R_POINTER)
  212.             return 0;
  213.         error("pointer not allowed");
  214.         return 1;
  215.     case K_STRUCT:
  216.     case K_UNION:
  217.         if (flags & R_STRUCT)
  218.             return 0;
  219.         error("struct/union not allowed");
  220.         return 1;
  221.     case K_CHAR:
  222.     case K_SHORT:
  223.     case K_INT:
  224.     case K_UNSIGNED:
  225.     case K_LONG:
  226.     case T_UCHAR:
  227.     case T_ULONG:
  228.         if (flags & R_INTEGRAL)
  229.             return 0;
  230.         error("integral not allowed");
  231.         return 1;
  232.     case K_FLOAT:
  233.     case K_DOUBLE:
  234.         if (flags & R_FLOATING)
  235.             return 0;
  236.         error("floating not allowed");
  237.         return 1;
  238.     default:
  239.         error("bad type");
  240.         return 1;
  241.     }
  242.     return 0;
  243. }
  244.  
  245. NODEP
  246. functy(np)
  247. NODEP np;
  248. {
  249.     int lt;
  250.  
  251.     lt = np->n_tptr->t_token;
  252.     if (lt != K_VOID)
  253.         mustty(np, R_ASSN);
  254.     switch (lt) {
  255.     case STAR:
  256.     case K_STRUCT:
  257.     case K_UNION:
  258.         return np->n_tptr;
  259.     }
  260.     lt = widen(lt);
  261.     return bas_type(lt);
  262. }
  263.  
  264. NODEP
  265. normalty(lp, rp)
  266. NODEP lp, rp;
  267. {
  268.     /* already checked types are R_ARITH */
  269.     /* rp may be NULL */
  270.     int lt, rt, rett;
  271.  
  272.     lt = lp->n_tptr->t_token;
  273.     if (rp)
  274.         rt = rp->n_tptr->t_token;
  275.     else
  276.         rt = K_INT;
  277.     rett = maxt(widen(lt), widen(rt));
  278.     return bas_type(rett);
  279. }
  280.  
  281. asn_chk(ltp, rp)
  282. NODEP ltp, rp;
  283. {
  284.     register NODEP p;    /*Jal*/
  285.  
  286.     switch (ltp->t_token) {
  287.     case K_STRUCT:
  288.     case K_UNION:
  289.         if (same_type(ltp, rp->n_tptr) == 0)
  290.             error("bad struct assign");
  291.         return;
  292.     case STAR:
  293.         if (mayzero(rp))
  294.             return;
  295.         if (mustty(rp, R_POINTER))
  296.             return;
  297.          /*
  298.          * Jal - allow for ptr = (void *) ptr.
  299.          */
  300.         p = rp->n_tptr->n_tptr;
  301.         if (p->t_token != K_VOID
  302.           && same_type(ltp->n_tptr, p) == 0)
  303.             warn("pointer types mismatch");
  304.         return;
  305.     default:
  306.         if (mustty(rp, R_ARITH))
  307.             return;
  308.     }
  309. }
  310.  
  311. chkcmp(np)
  312. NODEP np;
  313. {
  314.     /* already checked types are R_SCALAR */
  315.     int lt, rt;
  316.     NODEP lp = np->n_left, rp = np->n_right;
  317.  
  318.     lt = lp->n_tptr->t_token;
  319.     lt = (lt == STAR);
  320.     rt = rp->n_tptr->t_token;
  321.     rt = (rt == STAR);
  322.     if (lt && rt) {         /* ptr cmp ptr */
  323.         if (same_type(lp->n_tptr, rp->n_tptr) == 0) {
  324.             warn("cmp of diff ptrs");
  325.         }
  326.     } else if (lt) {        /* ptr cmp intg */
  327.         mustzero(rp);
  328.     } else if (rt) {        /* intg +-[ ptr */
  329.         mustzero(lp);
  330.     } /* else both ARITH */
  331. }
  332.  
  333. NODEP
  334. colonty(np)
  335. NODEP np;
  336. {
  337.     /* already checked types are R_SCALAR */
  338.     int lt, rt;
  339.     NODEP lp = np->n_left, rp = np->n_right;
  340.  
  341.     lt = lp->n_tptr->t_token;
  342.     lt = (lt == STAR);
  343.     rt = rp->n_tptr->t_token;
  344.     rt = (rt == STAR);
  345.     if (lt && rt) {         /* ptr : ptr */
  346.         warn(": diff ptrs");
  347.         return lp->n_tptr;
  348.     } else if (lt) {        /* ptr : intg */
  349.         mustzero(rp);
  350.         return lp->n_tptr;
  351.     } else if (rt) {
  352.         mustzero(lp);
  353.         return rp->n_tptr;
  354.     } else
  355.         return normalty(lp, rp);
  356. }
  357.  
  358. NODEP
  359. addty(np)
  360. NODEP np;
  361. {
  362.     /* already checked types are R_SCALAR */
  363.     /* op is '+' or '-' or '+=' or '-=' or '[' */
  364.     int oop = np->e_token;
  365.     int op;
  366.     int lt, rt;
  367.     NODEP lp = np->n_left, rp = np->n_right;
  368.  
  369.     op = oop;
  370.     if (isassign(op))
  371.         op -= ASSIGN 0;
  372.     lt = lp->n_tptr->t_token;
  373.     lt = (lt == STAR);
  374.     rt = rp->n_tptr->t_token;
  375.     rt = (rt == STAR);
  376.     if (lt && rt) {         /* ptr - ptr */
  377.         if (oop != '-' || same_type(lp->n_tptr, rp->n_tptr) == 0) {
  378.             error("bad +/-");
  379.             return lp->n_tptr;
  380.         }
  381.         np->e_token = PTRDIFF;
  382.         np->e_offs = lp->n_tptr->n_tptr->t_size;
  383.         return bas_type(K_INT);
  384.     } else if (lt) {        /* ptr +-[ intg */
  385. pandi:
  386.         mustty(rp, R_INTEGRAL);
  387.         np->e_offs = lp->n_tptr->n_tptr->t_size;
  388.         if (op == '+')
  389.             np->e_token += PTRADD-'+';
  390.         else if (op == '-')
  391.             np->e_token += PTRSUB-'-';
  392.         return lp->n_tptr;
  393.     } else if (rt) {        /* intg +-[ ptr */
  394.         if (isassign(oop) || op == '-') {
  395.             error("illegal int op ptr");
  396.             return bas_type(K_INT);
  397.         }
  398.         /* switch sides so intg is on right */
  399.         np->n_left = rp;
  400.         np->n_right = lp;
  401.         lp = rp;
  402.         rp = np->n_right;
  403.         goto pandi;
  404.     } else {        /* intg +- intg */
  405.         return normalty(lp, rp);
  406.     }
  407. }
  408.  
  409. mustzero(np)
  410. NODEP np;
  411. {
  412.     if (np->e_token == ICON && np->e_ival == 0) {
  413.         return;
  414.     }
  415.     error("bad ':' combination");
  416. }
  417.  
  418. mayzero(np)
  419. NODEP np;
  420. {
  421.     if (np->e_token == ICON && np->e_ival == 0) {
  422.         return 1;
  423.     }
  424.     return 0;
  425. }
  426.  
  427. widen(ty)
  428. {
  429.     switch (ty) {
  430.     case K_CHAR:
  431.     case T_UCHAR:
  432.         return K_INT;
  433.     case K_SHORT:
  434.         return K_INT;
  435.     case K_FLOAT:
  436.         return K_DOUBLE;
  437.     default:
  438.         return ty;
  439.     }
  440. }
  441.  
  442. int pri_t[] = {
  443.     1, 6,        /* uchar, ulong */
  444.     5,2,4,3,0,    /* long, short, uns, int, char */
  445.     7,8,9        /* float, double, void */
  446. };
  447.  
  448.  
  449. extern nmerrors;
  450.  
  451. maxt(t1, t2)
  452. {
  453.  
  454.     if (nmerrors)
  455.         return K_INT;
  456.     if (pri_t[t1-FIRST_BAS] > pri_t[t2-FIRST_BAS])
  457.         return t1;
  458.     return t2;
  459. }
  460.