# 2.11BSD#431 - /usr/ingres/source/ovqp/typecheck.c

##### Functions

    f8tof4            X
    ftoi2             X
    ftoi4             X
    i2toi4            X
    i4toi2            X
    itof              X
    typecheck         X
    typecoerce        X

       1: # include   "../ingres.h"
       2: # include   "../aux.h"
       3: # include   "../tree.h"
       4: # include   "../symbol.h"
       5: # include   "ovqp.h"
       6: /*
       7: ** TYPECHECK
       8: **
       9: **	Performs typechecking and conversions where appropriate .
      10: **	Prohibits mixed type expressions.
      11: */
      12:
      13: typecheck(pp1, pp2, opval)
      14: struct symbol   *pp1, *pp2;
      15: int     opval;
      16: {
      17:     register struct symbol  *p1, *p2;
      18:     register int        i;
      19:
      20:     p1 = pp1;
      21:     p2 = pp2;
      22:
      23:     i = (p1->type == CHAR & p2->type == CHAR);  /* c is true only if both are chars */
      24:     switch (opval)
      25:     {
      26:
      27:       case opCONCAT:
      28:         if (!i)
      29:             ov_err(NUMERIC);    /* numeric in a char operator */
      30:         return; /* else no further checking is needed */
      31:
      32:       case opADD:
      33:       case opSUB:
      34:       case opMUL:
      35:       case opDIV:
      36:       case opPOW:
      37:       case opMOD:
      38:         if (i)
      39:             ov_err(BADCHAR);    /* arithmetic operation on two character fields */
      40:     }
      41:
      42:     /* first check for identical types of symbols */
      43:     if (p1->type == p2->type)
      44:     {
      45:         if (p1->len == p2->len)
      46:             return;
      47:         /* lengths are different. make p2 point to the smaller one */
      48:         if (p1->len < p2->len)
      49:         {
      50:             p2 = p1;
      51:             p1 = pp2;
      52:         }
      53:
      54:         switch (p2->type)
      55:         {
      56:
      57:           case INT:
      58:             if (p1->len == 4)
      59:                 i2toi4(p2);
      60:
      61:           case CHAR:
      62:             return; /* done if char or int */
      63:
      64:           case FLOAT:
      65:             f8tof4(p2);
      66:             return;
      67:         }
      68:     }
      69:
      70:     /* at least one symbol is an INT or FLOAT. The other can't be a CHAR */
      71:     if (p1->type == CHAR || p2->type == CHAR)
      72:         ov_err(BADMIX); /* attempting binary operation on one CHAR field with a numeric */
      73:
      74:     /* one symbol is an INT and the other a FLOAT */
      75:     if (p2->type == INT)
      76:     {
      77:         /* exchange so that p1 is an INT and p2 is a FLOAT */
      78:         p1 = p2;
      79:         p2 = pp1;
      80:     }
      81:
      82:     /* p1 is an INT and p2 a FLOAT */
      83:     itof(p1);
      84:     if (p2->len == 4)
      85:         f8tof4(p2);
      86: }
      87:
      88:
      89: typecoerce(tosx, ntype, nlen)
      90: struct stacksym *tosx;
      91: int     ntype;
      92: int     nlen;
      93:
      94: /*
      95: **	Coerce the top of stack symbol to the
      96: **	specified type and length. If the current
      97: **	value is a character then it must be converted
      98: **	to numeric. A user error will occure is the
      99: **	char is not syntaxtically correct.
     100: */
     101:
     102: {
     103:     register struct stacksym    *tos;
     104:     register char           *cp;
     105:     register int            *val;
     106:     int             ret;
     107:     char                temp[256];
     108:
     109:     tos = tosx;
     110:
     111:     if (tos->type == CHAR)
     112:     {
     113:         val = tos->value;
     114:         cp = temp;
     115:         bmove(cpderef(tos->value), cp, tos->len & I1MASK);
     116:         cp[tos->len & I1MASK] = '\0';
     117:         if (ntype == FLOAT)
     118:             ret = atof(cp, val);
     119:         else
     120:         {
     121:             if (nlen == 4)
     122:                 ret = atol(cp, val);
     123:             else
     124:                 ret = atoi(cp, val);
     125:         }
     126:         if (ret < 0)
     127:             ov_err(CHARCONVERT);
     128:         tos->type = ntype;
     129:         tos->len = nlen;
     130:     }
     131:     else
     132:         rcvt(tos, ntype, nlen);
     133: }
     134:
     135:
     136: i2toi4(pp)
     137: struct symbol *pp;
     138: {
     139:     register struct symbol  *p;
     140:
     141:     p = pp;
     142:
     143:     i4deref(p->value) = i2deref(p->value);
     144:     p->len = 4;
     145: }
     146:
     147:
     148: i4toi2(pp)
     149: struct symbol *pp;
     150: {
     151:     register struct symbol  *p;
     152:
     153:     p = pp;
     154:
     155:     i2deref(p->value) = i4deref(p->value);
     156:     p->len = 2;
     157: }
     158:
     159:
     160: itof(pp)
     161: struct symbol *pp;
     162: {
     163:     register struct symbol  *p;
     164:
     165:     p  = pp;
     166:
     167:     if  (p->len == 4)
     168:         f8deref(p->value) = i4deref(p->value);
     169:     else
     170:         f8deref(p->value) = i2deref(p->value);
     171:     p->type = FLOAT;
     172:     p->len= 8;
     173: }
     174:
     175:
     176: ftoi2(pp)
     177: struct symbol *pp;
     178: {
     179:     register struct symbol  *p;
     180:
     181:     p = pp;
     182:
     183:     i2deref(p->value) = f8deref(p->value);
     184:     p->type = INT;
     185:     p->len = 2;
     186: }
     187:
     188:
     189: ftoi4(pp)
     190: struct symbol *pp;
     191: {
     192:     register struct symbol  *p;
     193:
     194:     p = pp;
     195:     i4deref(p->value) = f8deref(p->value);
     196:     p->type = INT;
     197:     p->len = 4;
     198: }
     199:
     200:
     201: f8tof4(pp)
     202: struct symbol   *pp;
     203: {
     204:     register struct symbol  *p;
     205:
     206:     p = pp;
     207:     f4deref(p->value) = f8deref(p->value);
     208:     p->len = 4;
     209: }

#### Defined functions

f8tof4 defined in line 201; used 2 times

- in line 65, 85

ftoi2 defined in line 176; used 1 times

- in /usr/ingres/source/ovqp/interp1.c line 205

ftoi4 defined in line 189; used 1 times

- in /usr/ingres/source/ovqp/interp1.c line 203

i2toi4 defined in line 136; used 2 times

- in line 59
- in /usr/ingres/source/ovqp/interp1.c line 216

i4toi2 defined in line 148; used 1 times

- in /usr/ingres/source/ovqp/interp1.c line 219

itof defined in line 160; used 8 times

- in line 83
- in /usr/ingres/source/ovqp/interp.c line 242-243(2), 279-280(2), 418, 634
- in /usr/ingres/source/ovqp/interp1.c line 199

typecheck defined in line 13; used 1 times

- in /usr/ingres/source/ovqp/interp.c line 211

typecoerce defined in line 89; used 5 times

- in /usr/ingres/source/ovqp/interp.c line 395-411(5)

Last modified: 1995-02-11 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1210 |