1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
   2: /* $Header: B1val.c,v 1.1 84/06/28 00:49:01 timo Exp $ */
   3: 
   4: /* General operations for objects */
   5: 
   6: #include "b.h"
   7: #include "b0con.h"
   8: #include "b1obj.h"
   9: #include "b1mem.h"
  10: #include "b2scr.h" /* TEMPORARY for at_nwl */
  11: #include "b2sem.h" /* TEMPORARY for grab */
  12: #ifndef SMALLNUMBERS
  13: #include "b1num.h" /* for ccopy, rrelease, grab, grab_num, grab_rat, grab_approx */
  14: #else
  15: #include "B1num.h" /* For grab */
  16: #endif
  17: 
  18: 
  19: #define LL (len < 200 ? 1 : 8)
  20: #define Len (len == 0 ? 0 : ((len-1)/LL+1)*LL)
  21: #define Adj(s) (unsigned) (sizeof(*Vnil)-sizeof(Vnil->cts)+(s))
  22: 
  23: #define Grabber() {if(len>Maxintlet)syserr("big grabber");}
  24: #define Regrabber() {if(len>Maxintlet)syserr("big regrabber");}
  25: 
  26: value etxt, elis, etab, elt;
  27: 
  28: long gr= 0;
  29: 
  30: Visible Procedure prgr() {at_nwl=No;printf(" gr:%ld",gr);gr=0;}
  31: 
  32: Hidden value grab(type, len) literal type; intlet len; {
  33:     unsigned syze; value v;
  34:     Grabber();
  35:     switch (type) {
  36:     case Num:
  37: #ifdef SMALLNUMBERS
  38:         syze= sizeof(number);
  39: #else
  40:         if (len >= 0) syze= Len*sizeof(digit);      /* Integral */
  41:         else if (len == -1) syze= sizeof(double);   /* Approximate */
  42:         else syze= 2*sizeof(value);         /* Rational */
  43: #endif
  44:         break;
  45:     case Tex: syze= (len+1)*sizeof(char); break; /* one extra for the '\0' */
  46:     case Com: syze= len*sizeof(value); break;
  47:     case ELT: syze= (len= 0); break;
  48:     case Lis:
  49:     case Tab: syze= Len*sizeof(value); break;
  50:     case Sim: syze= sizeof(simploc); break;
  51:     case Tri: syze= sizeof(trimloc); break;
  52:     case Tse: syze= sizeof(tbseloc); break;
  53:     case How: syze= sizeof(how); break;
  54:     case For: syze= sizeof(formal); break;
  55:     case Glo: syze= 0; break;
  56:     case Per: syze= sizeof(value); break;
  57:     case Fun:
  58:     case Prd: syze= sizeof(funprd); break;
  59:     case Ref: syze= sizeof(ref); break;
  60:     default:
  61:         printf("\ngrabtype{%c}\n", type);
  62:         syserr("grab called with unknown type");
  63:     }
  64:     v= (value) getmem(Adj(syze));
  65:     v->type= type; v->len= len; v->refcnt= 1;
  66: gr+=1;
  67:     return v;
  68: }
  69: 
  70: #ifdef SMALLNUMBERS
  71: Visible value grab_num(len) intlet len; { return grab(Num, len); }
  72: #else
  73: Visible value grab_num(len) register int len; {
  74:     integer v;
  75:     register int i;
  76: 
  77:     v = (integer) grab(Num, len);
  78:     for (i = Length(v)-1; i >= 0; --i) Digit(v, i) = 0;
  79:     return (value) v;
  80: }
  81: 
  82: Visible value grab_rat() {
  83:     return (value) grab(Num, -2);
  84: }
  85: 
  86: Visible value grab_approx() {
  87:     return (value) grab(Num, -1);
  88: }
  89: 
  90: Visible value regrab_num(v, len) value v; register int len; {
  91:     register unsigned syze;
  92: 
  93:     syze = Len * sizeof(digit);
  94:     regetmem(&v, Adj(syze));
  95:     Length(v) = len;
  96:     return v;
  97: }
  98: #endif
  99: 
 100: Visible value grab_tex(len) intlet len; {
 101:     if (len == 0) return copy(etxt);
 102:     return grab(Tex, len);
 103: }
 104: 
 105: Visible value grab_com(len) intlet len; { return grab(Com, len); }
 106: 
 107: Visible value grab_elt() { return copy(elt); }
 108: 
 109: Visible value grab_lis(len) intlet len; {
 110:     if (len == 0) return copy(elis);
 111:     return grab(Lis, len);
 112: }
 113: 
 114: Visible value grab_tab(len) intlet len; {
 115:     if (len == 0) return copy(etab);
 116:     return grab(Tab, len);
 117: }
 118: 
 119: Visible value grab_sim() { return grab(Sim, 0); }
 120: 
 121: Visible value grab_tri() { return grab(Tri, 0); }
 122: 
 123: Visible value grab_tse() { return grab(Tse, 0); }
 124: 
 125: Visible value grab_how() { return grab(How, 0); }
 126: 
 127: Visible value grab_for() { return grab(For, 0); }
 128: 
 129: Visible value grab_glo() { return grab(Glo, 0); }
 130: 
 131: Visible value grab_per() { return grab(Per, 0); }
 132: 
 133: Visible value grab_fun() { return grab(Fun, 0); }
 134: 
 135: Visible value grab_prd() { return grab(Prd, 0); }
 136: 
 137: Visible value grab_ref() { return grab(Ref, 0); }
 138: 
 139: Visible value copy(v) value v; {
 140:     if (v != Vnil && v->refcnt < Maxintlet) (v->refcnt)++;
 141:  gr+=1;
 142:     return v;
 143: }
 144: 
 145: Visible Procedure release(v) value v; {
 146:     intlet *r= &(v->refcnt);
 147:     if (v == Vnil) return;
 148:     if (*r == 0) syserr("releasing unreferenced value");
 149:  if(bugs){printf("releasing: "); if (Type(v) == Num) bugs= No; wri(v,No,No,No); bugs= Yes; line();}
 150:     if (*r < Maxintlet && --(*r) == 0) rrelease(v);
 151:  gr-=1;
 152: }
 153: 
 154: Hidden value ccopy(v) value v; {
 155:     literal type= v->type; intlet len= Length(v), k; value w;
 156:     w= grab(type, len);
 157:     switch (type) {
 158:     case Num:
 159: #ifdef SMALLNUMBERS
 160:         Numerator(w)= Numerator(v);
 161:         Denominator(w)= Denominator(v);
 162: #else
 163:         if (Integral(v)) {
 164:             register int i;
 165:             for (i = len-1; i >= 0; --i)
 166:                 Digit((integer)w, i) = Digit((integer)v, i);
 167:         } else if (Approximate(v))
 168:             Realval((real)w) = Realval((real)v);
 169:         else if (Rational(v)) {
 170:             Numerator((rational)w) =
 171:                 (integer) copy(Numerator((rational)v));
 172:             Denominator((rational)w) =
 173:                 (integer) copy(Denominator((rational)v));
 174:         }
 175: #endif
 176:         break;
 177:     case Tex:
 178:         strcpy(Str(w), Str(v));
 179:         break;
 180:     case Com:
 181:     case Lis:
 182:     case Tab:
 183:     case ELT:
 184:         {value *vp= Ats(v), *wp= Ats(w);
 185:             Overall *wp++= copy(*vp++);
 186:         } break;
 187:     case Sim:
 188:         {simploc *vv= (simploc *)Ats(v), *ww= (simploc *)Ats(w);
 189:             ww->i= copy(vv->i); ww->e= vv->e; /* No copy */
 190:         } break;
 191:     case Tri:
 192:         {trimloc *vv= (trimloc *)Ats(v), *ww= (trimloc *)Ats(w);
 193:             ww->R= copy(vv->R); ww->B= vv->B; ww->C= vv->C;
 194:         } break;
 195:     case Tse:
 196:         {tbseloc *vv= (tbseloc *)Ats(v), *ww= (tbseloc *)Ats(w);
 197:             ww->R= copy(vv->R); ww->K= copy(vv->K);
 198:         } break;
 199:     case How:
 200:         *((how *)Ats(w)) = *((how *)Ats(v));
 201:         break;
 202:     case For:
 203:         *((formal *)Ats(w)) = *((formal *)Ats(v));
 204:         break;
 205:     case Glo:
 206:         break;
 207:     case Per:
 208:         *Ats(w)= copy(*Ats(v));
 209:         break;
 210:     case Fun:
 211:     case Prd:
 212:         *((funprd *)Ats(w)) = *((funprd *)Ats(v));
 213:         break;
 214:     case Ref:
 215:         *((ref *)Ats(w)) = *((ref *)Ats(v));
 216:         break;
 217:     default:
 218:         syserr("ccopy called with unknown type");
 219:     }
 220:     return w;
 221: }
 222: 
 223: Hidden Procedure rrelease(v) value v; {
 224:     literal type= v->type; intlet len= Length(v), k;
 225:     switch (type) {
 226:     case Num:
 227: #ifndef SMALLNUMBERS
 228:         if (Rational(v)) {
 229:             release(Numerator((rational)v));
 230:             release(Denominator((rational)v));
 231:         }
 232:         break;
 233: #endif
 234:     case Tex:
 235:         break;
 236:     case Com:
 237:     case Lis:
 238:     case Tab:
 239:     case ELT:
 240:         {value *vp= Ats(v);
 241:             Overall release(*vp++);
 242:         } break;
 243:     case Sim:
 244:         {simploc *vv= (simploc *)Ats(v);
 245:             release(vv->i); /* No release of vv->e */
 246:         } break;
 247:     case Tri:
 248:         {trimloc *vv= (trimloc *)Ats(v);
 249:             release(vv->R);
 250:         } break;
 251:     case Tse:
 252:         {tbseloc *vv= (tbseloc *)Ats(v);
 253:             release(vv->R); release(vv->K);
 254:         } break;
 255:     case How:
 256:         {how *vv= (how *)Ats(v);
 257:             freemem((ptr) vv->fux);
 258:             release(vv->reftab);
 259:         } break;
 260:     case For:
 261:     case Glo:
 262:         break;
 263:     case Per:
 264:         release(*Ats(v));
 265:         break;
 266:     case Fun:
 267:     case Prd:
 268:         {funprd *vv= (funprd *)Ats(v);
 269:             if (vv->def == Use) {
 270:                 freemem((ptr) vv->fux);
 271:                 release(vv->reftab);
 272:             }
 273:         } break;
 274:     case Ref:
 275:         break;
 276:     default:
 277:         syserr("release called with unknown type");
 278:     }
 279:     v->type= '\0'; freemem((ptr) v);
 280: }
 281: 
 282: Visible Procedure uniql(ll) value *ll; {
 283:     if (*ll != Vnil && (*ll)->refcnt > 1) {
 284:         value c= ccopy(*ll);
 285:         release(*ll);
 286:         *ll= c;
 287:     }
 288: }
 289: 
 290: Visible Procedure xtndtex(a, d) value *a; intlet d; {
 291:     intlet len= Length(*a)+d;
 292:     Regrabber();
 293:     regetmem(a, Adj((len+1)*sizeof(char)));
 294:     (*a)->len= len;
 295: }
 296: 
 297: Visible Procedure xtndlt(a, d) value *a; intlet d; {
 298:     intlet len= Length(*a); intlet l1= Len, l2;
 299:     len+= d; l2= Len;
 300:     if (l1 != l2) {
 301:         Regrabber();
 302:         regetmem(a, Adj(l2*sizeof(value)));
 303:     }
 304:     (*a)->len= len;
 305: }
 306: 
 307: Visible Procedure initmem() {
 308:     etxt= grab(Tex, 0);
 309:     elis= grab(Lis, 0);
 310:     etab= grab(Tab, 0);
 311:     elt=  grab(ELT, 0);
 312:  notel= grab_lis(0); noting= No;
 313: }

Defined functions

ccopy defined in line 154; used 1 times
grab defined in line 32; used 23 times
grab_approx defined in line 86; used 1 times
grab_rat defined in line 82; used 1 times
initmem defined in line 307; used 1 times
prgr defined in line 30; used 1 times
regrab_num defined in line 90; used 1 times
release defined in line 145; used 233 times
rrelease defined in line 223; used 1 times
xtndtex defined in line 290; used 1 times

Defined variables

gr defined in line 28; used 5 times

Defined macros

Adj defined in line 21; used 4 times
Grabber defined in line 23; used 1 times
  • in line 34
LL defined in line 19; used 2 times
  • in line 20(2)
Len defined in line 20; used 5 times
Regrabber defined in line 24; used 2 times
Last modified: 1985-08-27
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 1765
Valid CSS Valid XHTML 1.0 Strict