![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to variable.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 variable.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: * //////////// variable.c /////////////
6: * /// J. P. Hawkins WH X4610 8C-001 ///
7: * ///// Fri Aug 24 17:00:44 1979 //////
8: * /////////////////////////////////////
9: * /////////////////////////////////////
10:
11: *
12: * Variable Allocation and Fetch routines
13: * For BITE
14: *
15: */
16: /* "@(#) variable.c: V 1.2 3/4/81" */
17: #include "bas.h"
18: union VARIABLE varbyts;
19: /*
20: * this is the symbol table (table of pointers) for numerical
21: * variables. The first subscript 'j' is calculated by the
22: * alpha name, the second subscript 'k' is calculated by the
23: * numeric part + 1. If no numeric is specified, k = 0
24: */
25: char *hicore; /* pointer lowest used corespace from
26: top of user area */
27:
28:
29: /*
30: * //////// FETCH VALUE OF VARIABLE ////////
31: *
32: * calling format:
33: *
34: * getvar(vstr, &value);
35: *
36: * where: vstr = string containing VALID variable name
37: * i.e. [a-z] or a[0-9] - z[0-9]
38: * float value = where actual value is returned to
39: */
40: getvar(vstr,valptr)
41: char vstr[];
42: double *valptr;
43: {
44: int j,k; /* symbol table indicies */
45: register char i; /* index to float bytes */
46: register char *ptr; /* pointer register used to copy bytes */
47:
48: j = vstr[0] - 'a'; /* compute j subscript */
49:
50: /*
51: * compute k subscript
52: */
53: if(vstr[1] == '\0') /* if no numeric part */
54: k = 0; /* then k = 0th column */
55: else
56: k = vstr[1] - '0' + 1; /* use numeric + 1th column */
57:
58: if(symtab[j][k] == 0) /*if no pointer for this variable */
59: /* (not allocated, yet) */
60: {
61: error2(inst.thing.linno,7,' '); /* UNNASSIGNED VARIABLE */
62: printf("- '%s'\n",vstr); /* print variable name */
63: *valptr = 0.0; /* return zero anyway */
64: return(-1);
65: }
66: else
67: {
68: ptr = symtab[j][k]; /* set byte copy ptr to data location */
69:
70: for(i=PREC-1; i >= 0; --i) /* copy the float byte-by byte */
71: varbyts.var4th[i] = *--ptr;
72:
73: *valptr = varbyts.var; /* now pass the value back to
74: the calling routine */
75: }
76: return(0);
77: }
78: /*
79: *
80: * //// ASSIGN A VALUE TO A VARIABLE ////
81: * /////// ALLOCATE SPACE IF NEC. ///////
82: *
83: * put the value into the allocated location.
84: * allocate a location if not already allocated
85: * calling format:
86: *
87: * putvar(vstr, value);
88: *
89: * where: vstr = string pointer to VALID variable name
90: * value = value to be assigned
91: */
92: putvar(vstr,value)
93: char vstr[]; /* valid variable string (name) */
94: double value; /* value to be assigned */
95: {
96: register char *ptr; /* pointer register used to copy bytes */
97: register char i; /* index to float bytes */
98: int j,k; /* symbol table indicies */
99:
100: j = vstr[0] - 'a'; /* compute j subscript */
101:
102: /*
103: * compute k subscript
104: */
105: if(vstr[1] == '\0') /* if no numeric part */
106: k = 0; /* then k = 0th column */
107: else
108: k = vstr[1] - '0' + 1;
109:
110: varbyts.var = value; /* stuff the float number (2 words)
111: in the float template to be copied
112: into data area byte-by-byte */
113: if(symtab[j][k] == 0) /* if no space yet allocated */
114: alloc(&symtab[j][k], PREC); /* then allocate space and
115: return pointer to symbol tab */
116: ptr = symtab[j][k]; /* set copy register to data address */
117:
118: for(i=PREC-1; i>=0; --i) /* copy into storage byte-by-byte */
119: *--ptr = varbyts.var4th[i];
120: }
121: /*
122: *
123: * //// INITIALIZE VARIABLES ////
124: */
125: initvar()
126: {
127: extern char txtbuf[];
128: hicore = &txtbuf[PGSIZ*NMPAG]; /* init pointer to top of user
129: data space */
130: }
131: /*
132: *
133: * //// ALLOCATE STORAGE FOR SPECIFIED BYTES ////
134: * return starting address of allocated space
135: *
136: * The data area is a TOP-DOWN allocation technique which follows
137: * rules that are inverse to BOTTOM-UP allocation or storage.
138: * The address of a datum is actually the address of the next higher
139: * core byte. When data is retrieved or stored, a pointer to that address
140: * is obtained, then each byte is retrieved or stored by first
141: * decrementing the pointer, THEN retrieving or inserting the byte in
142: * quiestion. Unlike bottom-up storage, the beginning of the area
143: * is always one address above-it and the end of the area is the last
144: * byte stored.
145: * In a bottom-up storage the beginning of data IS the first byte
146: * and the end of the area or piece of data or entire data area is
147: * AFTER the end of the data area or datum.
148: * These rules are consistant with the hardware of the PDP-11
149: * albeit auto-increment/decrement data retrieval and takes maximum
150: * advantage of the harware, thus producing the least amount of code.
151: *
152: * If these rules are adhered to at all times, there will be no error
153: * in data storage or retrieval.
154: *
155: * In light of the above, the value 'hicore' reflects the last byte
156: * occupied by the top-down storage area/txtbuf/stack or whatever.
157: */
158: alloc(datadr, numbyts)
159: char **datadr; /* pointer to symbol table entry */
160: int numbyts; /* number of bytes to be allocated */
161: {
162: *datadr = hicore; /* set symtab entry to loc of data */
163: hicore -= numbyts; /* bump down pointer to point to
164: lowest occupied data space */
165: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.