# 2.11BSD#431 - /usr/src/new/PORT/B/src/bint/b2tcE.c

##### Functions

    add_var           X
    badtyperr         X
    conc              X
    cyctyperr         X
    delreprtable      X
    end_vars          X
    in_vars           X
    knowntype         X
    newvar            X
    setreprtable      X
    start_vars        X
    t_repr            X

##### Variables

    outervar          X
    reprtable         X
    var_list          X

##### Macros

    Known             X

       1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
       2:
       3: /*
       4:   $Header: b2tcE.c,v 1.4 85/08/22 16:56:55 timo Exp $
       5: */
       6:
       7: /* process type unification errors */
       8:
       9: #include "b.h"
      10: #include "b1obj.h"
      11: #include "b2tcP.h"
      12: #include "b2tcE.h"
      13: #include "b2tcU.h"
      14:
      15: /*
      16:  * The variables from the users line are inserted in var_list.
      17:  * This is used to produce the right variable names
      18:  * in the error message.
      19:  * Call start_vars() when a new error context is established
      20:  * with the setting of curline.
      21:  */
      22:
      23: Hidden value var_list;
      24:
      25: Visible Procedure start_vars() {
      26:     var_list = mk_elt();
      27: }
      28:
      29: Visible Procedure add_var(tvar) polytype tvar; {
      30:     insert(tvar, &var_list);
      31: }
      32:
      33: Hidden bool in_vars(t) polytype t; {
      34:     return in(t, var_list);
      35: }
      36:
      37: Visible Procedure end_vars() {
      38:     release(var_list);
      39: }
      40:
      41: /* t_repr(u) is used to print polytypes when an error
      42:  * has occurred.
      43:  * Because the errors are printed AFTER unification, the variable
      44:  * polytypes in question have changed to the error-type.
      45:  * To print the real types in error, the table has to be
      46:  * saved in reprtable.
      47:  * The routines are called in unify().
      48:  */
      49:
      50: Hidden value reprtable;
      51: extern value typeof;        /* defined in b2tcP.c */
      52:
      53: Visible Procedure setreprtable() {
      54:     reprtable = copy(typeof);
      55: }
      56:
      57: Visible Procedure delreprtable() {
      58:     release(reprtable);
      59: }
      60:
      61: /* miscellaneous procs */
      62:
      63: Hidden value conc(v, w) value v, w; {
      64:     value c;
      65:     c = concat(v, w);
      66:     release(v); release(w);
      67:     return c;
      68: }
      69:
      70: Hidden bool newvar(u) polytype u; {
      71:     value u1;
      72:     char ch;
      73:     u1 = curtail(ident(u), one);
      74:     ch = charval(u1);
      75:     release(u1);
      76:     return (bool) ('0' <= ch && ch <= '9');
      77: }
      78:
      79: #define Known(tu) (!t_is_var(kind(tu)) && !t_is_error(kind(tu)))
      80:
      81: Hidden bool knowntype(u) polytype u; {
      82:     value tu;
      83:     tu = u;
      84:     while (t_is_var(kind(tu)) && in_keys(ident(tu), reprtable))
      85:         tu = *adrassoc(reprtable, ident(tu));
      86:     return Known(tu);
      87: }
      88:
      89: Hidden bool outervar = Yes;
      90:
      91: Hidden value t_repr(u) polytype u; {
      92:     typekind u_kind;
      93:     value c;
      94:
      95:     u_kind = kind(u);
      96:     if (t_is_number(u_kind)) {
      97:         return mk_text("0");
      98:     }
      99:     else if (t_is_text(u_kind)) {
     100:         return mk_text("''");
     101:     }
     102:     else if (t_is_tn(u_kind)) {
     103:         return mk_text("'' or 0");
     104:     }
     105:     else if (t_is_compound(u_kind)) {
     106:         intlet k, len = nsubtypes(u);
     107:         c = mk_text("(");
     108:         for (k = 0; k < len - 1; k++) {
     109:             c = conc(c, t_repr(subtype(u, k)));
     110:             c = conc(c, mk_text(", "));
     111:         }
     112:         c = conc(c, t_repr(subtype(u, k)));
     113:         return conc(c, mk_text(")"));
     114:     }
     115:     else if (t_is_error(u_kind)) {
     116:         return mk_text(" ");
     117:     }
     118:     else if (t_is_var(u_kind)) {
     119:         value tu;
     120:         tu = u;
     121:         while (t_is_var(kind(tu)) && in_keys(ident(tu), reprtable))
     122:             tu = *adrassoc(reprtable, ident(tu));
     123:         if (in_vars(u)) {
     124:             if (Known(tu)) {
     125:                 if (outervar) {
     126:                     outervar = No;
     127:                     c = conc(t_repr(tu), mk_text(" for "));
     128:                     outervar = Yes;
     129:                     return conc(c, copy(ident(u)));
     130:                 }
     131:                 else
     132:                     return t_repr(tu);
     133:             }
     134:             else {
     135:                 return copy(ident(u));
     136:             }
     137:         }
     138:         else if (Known(tu))
     139:             return t_repr(tu);
     140:         else if (newvar(u))
     141:             return mk_text(" ");
     142:         else
     143:             return copy(ident(u));
     144:     }
     145:     else if (t_is_table(u_kind)) {
     146:         if (knowntype(keytype(u))) {
     147:             if (knowntype(asctype(u))) {
     148:                 c = conc(mk_text("{["),
     149:                     t_repr(keytype(u)));
     150:                 c = conc(c, mk_text("]:"));
     151:                 c = conc(c, t_repr(asctype(u)));
     152:                 return conc(c, mk_text("}"));
     153:             }
     154:             else {
     155:                 c = conc(mk_text("table with type "),
     156:                     t_repr(keytype(u)));
     157:                 return conc(c, mk_text(" keys"));
     158:             }
     159:         }
     160:         else if (knowntype(asctype(u))) {
     161:             c = conc(mk_text("table with type "),
     162:                 t_repr(asctype(u)));
     163:             return conc(c, mk_text(" associates"));
     164:         }
     165:         else {
     166:             return mk_text("table");
     167:         }
     168:     }
     169:     else if (t_is_list(u_kind)) {
     170:         if (knowntype(asctype(u))) {
     171:             c = conc(mk_text("{"), t_repr(asctype(u)));
     172:             return conc(c, mk_text("}"));
     173:         }
     174:         else {
     175:             return mk_text("list");
     176:         }
     177:     }
     178:     else if (t_is_lt(u_kind)) {
     179:         if (knowntype(asctype(u)))
     180:             return conc(mk_text("list or table of "),
     181:                     t_repr(asctype(u)));
     182:         else
     183:             return mk_text("{}");
     184:     }
     185:     else if (t_is_tlt(u_kind)) {
     186:         if (knowntype(asctype(u)))
     187:             return conc(mk_text("text list or table of "),
     188:                     t_repr(asctype(u)));
     189:         else
     190:             return mk_text("text list or table");
     191:     }
     192:     else {
     193:         syserr(MESS(4300, "unknown polytype in t_repr"));
     194:         return mk_text("***");
     195:     }
     196: }
     197:
     198: /* now, the real error messages */
     199:
     200: Visible Procedure badtyperr(a, b) polytype a, b; {
     201:     value t;
     202:
     203: /*error4("incompatible types: ", ta, ", and ", tb); */
     204:
     205:     t = conc(t_repr(a), mk_text(" and "));
     206:     t = conc(t, t_repr(b));
     207:     error2(MESS(4301, "incompatible types "), t);
     208:     release(t);
     209: }
     210:
     211: Visible Procedure cyctyperr(a) polytype a; {
     212:     value vcyc;
     213:
     214:     vcyc = Vnil;
     215:     if (in_vars(a))
     216:         vcyc = ident(a);
     217:     else {
     218:         value n, m, nvars, v;
     219:         n = copy(one);
     220:         nvars = size(var_list);
     221:         while (compare(n, nvars) <= 0) {
     222:             v = th_of(n, var_list);
     223:             if (equal_vars(v, a) || contains(v, a)) {
     224:                 vcyc = ident(v);
     225:                 break;
     226:             }
     227:             m = n;
     228:             n = sum(n, one);
     229:             release(m); release(v);
     230:         }
     231:         release(n); release(nvars);
     232:         if (vcyc EQ Vnil) {
     233:             error2(MESS(4302, "unknown cyclic type"), ident(a));
     234:             syserr(MESS(4303, "unknown cyclic type"));
     235:             return;
     236:         }
     237:     }
     238:     error3(MESS(4304, "(sub)type of "), vcyc,
     239:         MESS(4305, " contains itself"));
     240: }

#### Defined functions

add_var defined in line 29; used 2 times

- in /usr/src/new/PORT/B/src/bint/b2stc.c line 519, 692

badtyperr defined in line 200; used 1 times

- in /usr/src/new/PORT/B/src/bint/b2tcU.c line 26

conc defined in line 63; used 20 times

- in line 109-113(4), 127-129(2), 148-163(8), 171-172(2), 180, 187, 205-206(2)

cyctyperr defined in line 211; used 1 times

- in /usr/src/new/PORT/B/src/bint/b2tcU.c line 183

delreprtable defined in line 57; used 1 times

- in /usr/src/new/PORT/B/src/bint/b2tcU.c line 27

end_vars defined in line 37; used 2 times

- in /usr/src/new/PORT/B/src/bint/b2stc.c line 52, 190

in_vars defined in line 33; used 2 times

- in line 123, 215

knowntype defined in line 81; used 6 times

- in line 146-147(2), 160, 170, 179, 186

newvar defined in line 70; used 1 times

- in line 140

setreprtable defined in line 53; used 1 times

- in /usr/src/new/PORT/B/src/bint/b2tcU.c line 24

start_vars defined in line 25; used 2 times

- in /usr/src/new/PORT/B/src/bint/b2stc.c line 45, 191

t_repr defined in line 91; used 14 times

- in line 109-112(2), 127-132(2), 139, 149-156(3), 162, 171, 181, 188, 205-206(2)

#### Defined variables

outervar defined in line 89; used 3 times

- in line 125-128(3)

reprtable defined in line 50; used 6 times

- in line 54-58(2), 84-85(2), 121-122(2)

var_list defined in line 23; used 6 times

- in line 26-38(4), 220-222(2)

#### Defined macros

Known defined in line 79; used 3 times

- in line 86, 124, 138

Last modified: 1985-08-27 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1084 |