![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dim.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / basic / bite / src|
Return to dim.c CVS log | Up to [Research Unix] / researchv10no / cmd / basic / bite / src |
1.1 ! root 1: /* Copyright Bell Telephone Laboratories Whippany, N.J. ! 2: ! 3: * ///////////////////////////////////// ! 4: * ///////////////////////////////////// ! 5: * /////////////// dim.c /////////////// ! 6: * /// J. P. Hawkins WH X4610 8C-001 /// ! 7: * ///// Fri Aug 24 17:24:13 1979 ////// ! 8: * ///////////////////////////////////// ! 9: * ///////////////////////////////////// ! 10: ! 11: * Array allocator for ! 12: * BITE ! 13: * Reference: Donald.E.Knuth ! 14: * "Fundamental Algorithms" ! 15: * Vol. 1 PP 296,298 ! 16: * ! 17: * Storage is allocated so that: ! 18: * ! 19: * LOC(ARRAY[I,J,K,L]) = BASEADDR + a1*I + a2*J + a3*K + L ! 20: * ! 21: * The constants a1,a2,a3,a4 ... ak-1 are calculated at dimension time ! 22: * and stored as part of the header in the array data. ! 23: * The storage of these constants could be saved by doing a calculation ! 24: * every time an array element is referenced. The tradeoff is access ! 25: * speed versus some core real estate. ! 26: * ! 27: * +---------------+ BEGINNING OF ALLOCATED SPACE ! 28: * | | NUMBER OF DIMENSIONS ! 29: * +---------------+ ! 30: * | I1 | DIMENSION 1 ! 31: * +---------------+ ! 32: * | I2 | DIMENSION 2 ! 33: * +---------------+ ! 34: * | I3 | DIMENSION 3 ! 35: * +---------------+ ! 36: * | ............ | ! 37: * +---------------+ ! 38: * | Ik | DIMENSION k ! 39: * +---------------+ ! 40: * | a1 | Constants a1 .... ak-1 ! 41: * +---------------+ ! 42: * | ............ | ! 43: * +---------------+ ! 44: * | ak-1 | ! 45: * +---------------+ ! 46: * | | BEGINNING OF DATA AREA ! 47: * +---------------+ ! 48: * | | ! 49: * ~~ ~~ ! 50: * | | ! 51: * +---------------+ ! 52: * | | ! 53: * +---------------+ ! 54: */ ! 55: /* "@(#) dim.c: V 1.4 3/4/81" */ ! 56: /* ! 57: * ! 58: * ////// DIMENSION STATEMENT ////// ! 59: */ ! 60: /* "@(#) dim.c: V 1.4 3/4/81" */ ! 61: #include "bas.h" ! 62: extern char *hicore; ! 63: extern int _comflg; /* common flag */ ! 64: char * asymtab[26][11]; /* array name symbol table */ ! 65: #ifdef STRINGS ! 66: char * sasymtab[26][11]; /* string array name symbol table */ ! 67: #endif ! 68: ! 69: dim() ! 70: { ! 71: char *clptr; /* temp pointer used for class */ ! 72: char expfld[40]; /* expression field */ ! 73: int type; ! 74: ! 75: clptr = expr; ! 76: type = class(&clptr,expfld); ! 77: switch(type) ! 78: { ! 79: case VACLASS: ! 80: return(ndim()); ! 81: break; ! 82: #ifdef STRINGS ! 83: case SACLASS: ! 84: return(sdim()); ! 85: break; ! 86: #endif ! 87: default: ! 88: error(inst.thing.linno, 21); /* BAD DIMENSION SYNTAX */ ! 89: return(-1); ! 90: } ! 91: return 0; ! 92: } ! 93: #ifdef STRINGS ! 94: /* ! 95: * String dimension ! 96: */ ! 97: sdim() ! 98: { ! 99: char arname[3]; /* array symbol name */ ! 100: double dimlist[MAXDIM]; /* dimension list */ ! 101: double numdim; /* number of dimensions */ ! 102: int totsiz; /* space to be allocated */ ! 103: unsigned int bytsiz; /* same as totsiz in int form */ ! 104: register int *iptr; ! 105: int i; ! 106: ! 107: int j,k; /* symbol table indicies */ ! 108: ! 109: ! 110: /* ! 111: * GET ARRAY SYMBOL NAME, NUMBER IF DIMENSIONS & ! 112: * PUT THE VALUE OF EACH DIMENSION IN DIMLIST ! 113: */ ! 114: if(getdims(expr,arname,&numdim,dimlist) < 0) ! 115: return(-1); ! 116: if(numdim == 1.0) /* if one dim specified */ ! 117: { ! 118: dimlist[1] = 1.0; /* it's an N X 1 array */ ! 119: } ! 120: j = arname[0] - 'a'; /* compute j subscript */ ! 121: ! 122: /* ! 123: * compute k subscript ! 124: */ ! 125: if(arname[1] == '\0') /* if no numeric part */ ! 126: k = 0; /* then k = 0th column */ ! 127: else ! 128: k = arname[1] - '0' + 1; ! 129: ! 130: /* ! 131: * SET SYMBOL TABLE POINTER ! 132: */ ! 133: if(sasymtab[j][k] == 0) ! 134: { ! 135: alloc(&sasymtab[j][k],sizeof(int)); ! 136: } ! 137: else ! 138: { ! 139: if(_comflg) /* if vars commoned */ ! 140: return(0); /* just no_op */ ! 141: error(inst.thing.linno, 23); /* REDUNDANT DIM STATEMENT */ ! 142: return(-1); ! 143: } ! 144: /* ! 145: * CALCULATE MEMORY NEEDED FOR DATA ! 146: */ ! 147: totsiz = (int)(dimlist[0] * dimlist[1]); ! 148: ! 149: totsiz += 2; /* add space for header */ ! 150: ! 151: totsiz = sizeof(int) * totsiz; /* convert to size in bytes */ ! 152: /* ! 153: * IF TOTSIZ IS GREATER THAN HIGHEST POS 16 BIT INTEGER, ! 154: * FORCE IT TO EQUAL THAT MAX SO THAT SIZE CHECK FAILS. ! 155: * OTHERWISE BYTSIZ WILL CONVERT TO 0 AND APPEAR TO BE ! 156: * LEGALLY SMALL. ! 157: */ ! 158: if(totsiz > 32767) totsiz = 32767; ! 159: bytsiz = totsiz; /* convert size to integer */ ! 160: /* ! 161: * Return error if not enough space left ! 162: */ ! 163: if((hicore - bytsiz) <= linptr) ! 164: { ! 165: error(inst.thing.linno, 24); /* NOT ENOUGH ADDITIONAL CORE */ ! 166: return(-1); ! 167: } ! 168: i = (int)hicore - (int)bytsiz; ! 169: while((unsigned)hicore > i) ! 170: { ! 171: *hicore = '\0'; /* zero each location in array */ ! 172: hicore -= 1; ! 173: } ! 174: ! 175: iptr = (int *)sasymtab[j][k]; /* get pointer to header */ ! 176: *--iptr = (int)numdim; /* put in number of dims */ ! 177: *--iptr = (int)dimlist[0]; /* put in XMAX */ ! 178: *--iptr = (int)dimlist[1]; /* put in YMAX */ ! 179: return(0); ! 180: } ! 181: #endif ! 182: /* ! 183: * Numerical dimension ! 184: */ ! 185: ndim() ! 186: { ! 187: char *putflot(),*getflot(); ! 188: char arname[3]; /* array symbol name */ ! 189: double conlist[MAXDIM]; /* list of constants a1 -- ak-1 */ ! 190: double dimlist[MAXDIM]; /* dimension list */ ! 191: double numdim; /* number of dimensions */ ! 192: double numcon; /* number of constants */ ! 193: double totsiz; /* space to be allocated in float */ ! 194: unsigned int bytsiz; /* same as totsiz in int form */ ! 195: ! 196: register char *ptr; ! 197: register i; ! 198: register x; ! 199: int j,k; /* symbol table indicies */ ! 200: ! 201: ptr = expr; /* get pointer to command argument string */ ! 202: ! 203: /* ! 204: * GET ARRAY SYMBOL NAME, NUMBER IF DIMENSIONS & ! 205: * PUT THE VALUE OF EACH DIMENSION IN DIMLIST ! 206: */ ! 207: if(getdims(expr,arname,&numdim,dimlist) < 0) ! 208: return(-1); ! 209: ! 210: /* ! 211: * CALCULATE CONSTANTS a1....ak-1 ! 212: * and PUT THEM IN CONLIST ! 213: */ ! 214: for(x=1; dimlist[x] != 0.0; x++) ! 215: { ! 216: conlist[x-1] = 1; /* init this entry */ ! 217: for(i=x; dimlist[i] != 0.0; i++) ! 218: { ! 219: conlist[x-1] *= (dimlist[i] ); ! 220: } ! 221: } ! 222: conlist[x-1] = 0.0; ! 223: numcon = x-1; /* number of constants */ ! 224: j = arname[0] - 'a'; /* compute j subscript */ ! 225: ! 226: /* ! 227: * compute k subscript ! 228: */ ! 229: if(arname[1] == '\0') /* if no numeric part */ ! 230: k = 0; /* then k = 0th column */ ! 231: else ! 232: k = arname[1] - '0' + 1; ! 233: ! 234: /* ! 235: * SET SYMBOL TABLE POINTER ! 236: */ ! 237: if(asymtab[j][k] == 0) ! 238: alloc(&asymtab[j][k],PREC); ! 239: else ! 240: { ! 241: if(_comflg) /* if vars commoned */ ! 242: return(0); /* just no_op */ ! 243: error(inst.thing.linno, 23); /* REDUNDANT DIM STATEMENT */ ! 244: return(-1); ! 245: } ! 246: ! 247: totsiz = 1.0; ! 248: /* ! 249: * CALCULATE MEMORY NEEDED FOR DATA ! 250: */ ! 251: for(i=0; dimlist[i] != 0.0; i++) ! 252: { ! 253: totsiz *= dimlist[i]; ! 254: } ! 255: ! 256: totsiz += numdim + numcon; /* add space needed for dimensions ! 257: and constants */ ! 258: ! 259: totsiz = PREC * totsiz; /* convert to size in bytes */ ! 260: /* ! 261: * IF TOTSIZ IS GREATER THAN HIGHEST POS 16 BIT INTEGER, ! 262: * FORCE IT TO EQUAL THAT MAX SO THAT SIZE CHECK FAILS. ! 263: * OTHERWISE BYTSIZ WILL CONVERT TO 0 AND APPEAR TO BE ! 264: * LEGALLY SMALL. ! 265: */ ! 266: if(totsiz > 32767.0) totsiz = 32767.0; ! 267: bytsiz = totsiz; /* convert size to integer */ ! 268: /* ! 269: * Return error if not enough space left ! 270: */ ! 271: if((hicore - bytsiz) <= linptr) ! 272: { ! 273: error(inst.thing.linno, 24); /* NOT ENOUGH ADDITIONAL CORE */ ! 274: return(-1); ! 275: } ! 276: i = (int)hicore - (int)bytsiz; ! 277: while((unsigned)hicore > i) ! 278: { ! 279: *hicore = '\0'; /* zero each location in array */ ! 280: hicore -= 1; ! 281: } ! 282: ! 283: ptr = asymtab[j][k]; /* get pointer to header */ ! 284: /* ! 285: * PUT NUMBER OF DIMENSIONS IN HEADER ! 286: */ ! 287: ptr = putflot(numdim, ptr); ! 288: ! 289: /* ! 290: * PUT DIMENSIONS IN HEADER ! 291: */ ! 292: for(i=0; dimlist[i] != 0.0; i++) ! 293: ptr = putflot(dimlist[i], ptr); ! 294: ! 295: /* ! 296: * PUT CONSTANT LIST IN HEADER ! 297: */ ! 298: for(i=0; conlist[i] != 0.0; i++) ! 299: ptr = putflot(conlist[i], ptr); ! 300: return(0); ! 301: } ! 302: /* ! 303: * ! 304: * ////// PUTFLOT ////// ! 305: * ! 306: * Copy floating point number into allocated memory ! 307: * return new pointer value ! 308: */ ! 309: char * ! 310: putflot(value,ptr) ! 311: double value; ! 312: char *ptr; ! 313: { ! 314: register char *p; /* register pointer */ ! 315: register i; /* regster index */ ! 316: ! 317: p = ptr; /* set reister to address */ ! 318: ! 319: varbyts.var = value; /* stuff float into byte template */ ! 320: ! 321: /* ! 322: * copy float number into allocated space ! 323: * byte by byte from top down ! 324: */ ! 325: for(i=PREC-1; i>=0; --i) ! 326: *--p = varbyts.var4th[i]; ! 327: ! 328: return(p); /* return new pointer value */ ! 329: } ! 330: ! 331: /* ! 332: * ////// GETFLOT ////// ! 333: * ! 334: * Copy floating point number OUT of allocated memory ! 335: * return the floating point value in *valptr ! 336: * return the next pointer down ! 337: */ ! 338: char * ! 339: getflot(valptr,ptr) ! 340: double *valptr; ! 341: char *ptr; ! 342: { ! 343: register char *p; /* register pointer */ ! 344: register i; /* register index */ ! 345: ! 346: p = ptr; /* set register to address */ ! 347: ! 348: for(i=PREC-1; i>=0; --i) ! 349: varbyts.var4th[i] = *--p; ! 350: ! 351: *valptr = varbyts.var; /* return the value to calling routine */ ! 352: ! 353: return(p); /* return new pointer */ ! 354: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.