![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to util.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / parse|
Return to util.c CVS log | Up to [local] / OpenXM_contrib2 / asir2000 / parse |
1.1 noro 1: /* $OpenXM: OpenXM/src/asir99/parse/util.c,v 1.1.1.1 1999/11/10 08:12:34 noro Exp $ */
2: #include "ca.h"
3: #include "base.h"
4: #include "parse.h"
5: #if defined(THINK_C) || defined(VISUAL)
6: #include <stdarg.h>
7: #else
8: #include <varargs.h>
9: #endif
10: #include <ctype.h>
11:
12: int length(n)
13: NODE n;
14: {
15: int i;
16:
17: for ( i = 0; n; n = NEXT(n), i++ );
18: return i;
19: }
20:
21: int argc(a)
22: NODE a;
23: {
24: int i;
25:
26: for ( i = 0; a; i++, a = NEXT(a) );
27: return ( i );
28: }
29:
30: void stoarg(s,acp,av)
31: char *s;
32: int *acp;
33: char **av;
34: {
35: int i;
36:
37: for ( i = 0; ; i++ ) {
38: for ( ; *s && isspace(*s); s++ );
39: if ( *s ) {
40: for ( av[i] = s; *s && !isspace(*s); s++ );
41: if ( *s )
42: *s++ = 0;
43: } else {
44: *acp = i;
45: return;
46: }
47: }
48: }
49:
50: #if 0
51: unsigned int ator(addr,r)
52: unsigned int addr;
53: Obj *r;
54: {
55: N n;
56: Q q;
57:
58: if ( !addr )
59: q = 0;
60: if ( addr < BASE )
61: STOQ(addr,q);
62: else {
63: n = NALLOC(2); PL(n) = 2;
64: BD(n)[0] = addr-BASE; BD(n)[1] = addr>>BSH; NTOQ(n,1,q);
65: }
66: *r = (Obj)q;
67: }
68: #endif
69:
70: void getarray(a,ind,vp)
71: pointer a;
72: NODE ind;
73: pointer *vp;
74: {
75: Obj len,row,col;
76: int i,l;
77: NODE n,n0;
78: VECT v;
79:
80: for ( ; ind; ind = NEXT(ind) ) {
81: if ( !a )
82: error("getarray : array or list expected");
83: switch ( OID(a) ) {
84: case O_VECT:
85: len = (Obj)BDY(ind);
86: if ( !rangecheck(len,((VECT)a)->len) )
87: error("getarray : Out of range");
88: else
89: a = (pointer)(BDY((VECT)a)[QTOS((Q)len)]);
90: break;
91: case O_MAT:
92: row = (Obj)BDY(ind);
93: if ( !rangecheck(row,((MAT)a)->row) )
94: error("getarray : Out of range");
95: else if ( NEXT(ind) ) {
96: ind = NEXT(ind);
97: col = (Obj)BDY(ind);
98: if ( !rangecheck(col,((MAT)a)->col) )
99: error("getarray : Out of range");
100: else
101: a = (pointer)(BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)]);
102: } else {
103: NEWVECT(v); v->len = ((MAT)a)->col;
104: v->body = (pointer *)BDY((MAT)a)[QTOS((Q)row)];
105: a = (pointer)v;
106: }
107: break;
108: case O_LIST:
109: n0 = BDY((LIST)a); i = QTOS((Q)BDY(ind));
110: for ( l = 0, n = n0; n; n = NEXT(n), l++ );
111: if ( i < 0 || i >= l )
112: error("getarray : Out of range");
113: else {
114: for ( n = n0, l = 0; l < i; l++, n = NEXT(n) );
115: a = (pointer)BDY(n);
116: }
117: break;
118: default:
119: error("getarray : array or list expected");
120: break;
121: }
122: }
123: *vp = a;
124: }
125:
126: void putarray(a,ind,b)
127: pointer a;
128: NODE ind;
129: pointer b;
130: {
131: Obj len,row,col;
132: int i,l;
133: NODE n,n0;
134:
135: for ( ; ind; ind = NEXT(ind) ) {
136: if ( !a )
137: error("putarray : array expected");
138: switch ( OID(a) ) {
139: case O_VECT:
140: len = (Obj)BDY(ind);
141: if ( !rangecheck(len,((VECT)a)->len) )
142: error("putarray : Out of range");
143: else if ( NEXT(ind) )
144: a = BDY((VECT)a)[QTOS((Q)len)];
145: else
146: BDY((VECT)a)[QTOS((Q)len)] = b;
147: break;
148: case O_MAT:
149: row = (Obj)BDY(ind);
150: if ( !rangecheck(row,((MAT)a)->row) )
151: error("putarray : Out of range");
152: else if ( NEXT(ind) ) {
153: ind = NEXT(ind);
154: col = (Obj)BDY(ind);
155: if ( !rangecheck(col,((MAT)a)->col) )
156: error("putarray : Out of range");
157: else if ( NEXT(ind) )
158: a = BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)];
159: else
160: BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)] = b;
161: } else
162: error("putarray : invalid assignment");
163: break;
164: case O_LIST:
165: if ( NEXT(ind) ) {
166: n0 = BDY((LIST)a); i = QTOS((Q)BDY(ind));
167: for ( l = 0, n = n0; n; n = NEXT(n), l++ );
168: if ( i < 0 || i >= l )
169: error("putarray : Out of range");
170: else {
171: for ( n = n0, l = 0; l < i; l++, n = NEXT(n) );
172: a = (pointer)BDY(n);
173: }
174: } else
175: error("putarray : invalid assignment");
176: break;
177: default:
178: error("putarray : array expected");
179: break;
180: }
181: }
182: }
183:
184: int rangecheck(a,n)
185: Obj a;
186: int n;
187: {
188: N m;
189:
190: if ( !a )
191: return 1;
192: if ( OID(a) != O_N || !RATN(a) || !INT(a) || SGN((Q)a) < 0 )
193: return 0;
194: m = NM((Q)a);
195: if ( PL(m) > 1 || BD(m)[0] >= (unsigned int)n )
196: return 0;
197: return 1;
198: }
199:
200: int zp(p)
201: P p;
202: {
203: int r;
204: DCP dc;
205:
206: if ( !p )
207: r = 1;
208: else if ( NUM(p) )
209: r = INT((Q)p)?1:0;
210: else
211: for ( dc = DC(p), r = 1; dc && r; dc = NEXT(dc) )
212: r &= zp(COEF(dc));
213: return ( r );
214: }
215:
216: #if defined(THINK_C) || defined(VISUAL)
217: NODE mknode(int ac,...)
218: {
219: va_list ap;
220: int i;
221: NODE n0,n;
222:
223: va_start(ap,ac);
224: for ( i = 0, n0 = 0; i < ac; i++ ) {
225: NEXTNODE(n0,n);
226: BDY(n)=va_arg(ap, pointer);
227: }
228: va_end(ap);
229: if ( n0 )
230: NEXT(n)=0;
231: return n0;
232: }
233:
234: FNODE mkfnode(int ac,fid id,...)
235: {
236: va_list ap;
237: int i;
238: FNODE r;
239:
240: va_start(ap,id);
241: NEWFNODE(r,ac); ID(r) = id;
242: for ( i = 0; i < ac; i++ )
243: r->arg[i] = va_arg(ap, pointer);
244: va_end(ap);
245: return r;
246: }
247:
248: SNODE mksnode(int ac,sid id,...)
249: {
250: va_list ap;
251: int i;
252: SNODE r;
253:
254: va_start(ap,id);
255: NEWSNODE(r,ac); ID(r) = id;
256: for ( i = 0; i < ac; i++ )
257: r->arg[i] = va_arg(ap, pointer);
258: va_end(ap);
259: return r;
260: }
261: #else
262: NODE mknode(va_alist)
263: va_dcl
264: {
265: va_list ap;
266: int ac,i;
267: NODE n0,n;
268:
269: va_start(ap);
270: ac = va_arg(ap,int);
271: for ( i = 0, n0 = 0; i < ac; i++ ) {
272: NEXTNODE(n0,n);
273: BDY(n)=va_arg(ap, pointer);
274: }
275: va_end(ap);
276: if ( n0 )
277: NEXT(n)=0;
278: return n0;
279: }
280:
281: FNODE mkfnode(va_alist)
282: va_dcl
283: {
284: va_list ap;
285: int ac,i;
286: FNODE r;
287:
288: va_start(ap);
289: ac = va_arg(ap, int);
290: NEWFNODE(r,ac); ID(r) = va_arg(ap, fid);
291: for ( i = 0; i < ac; i++ )
292: r->arg[i] = va_arg(ap, pointer);
293: va_end(ap);
294: return r;
295: }
296:
297: SNODE mksnode(va_alist)
298: va_dcl
299: {
300: va_list ap;
301: int ac,i;
302: SNODE r;
303:
304: va_start(ap);
305: ac = va_arg(ap, int);
306: NEWSNODE(r,ac); ID(r) = va_arg(ap, sid);
307: for ( i = 0; i < ac; i++ )
308: r->arg[i] = va_arg(ap, pointer);
309: va_end(ap);
310: return r;
311: }
312: #endif
313:
314: void makevar(str,p)
315: char *str;
316: P *p;
317: {
318: VL vl;
319: V v;
320: P t;
321:
322: for ( vl = CO; ; )
323: if ( NAME(VR(vl)) && !strcmp(NAME(VR(vl)),str) ) {
324: MKV(VR(vl),t); *p = t;
325: return;
326: } else if ( !NEXT(vl) ) {
327: NEWV(v); v->attr = (pointer)V_IND;
328: NAME(v) = (char *)CALLOC(strlen(str)+1,sizeof(char));
329: strcpy(NAME(v),str);
330: NEWVL(NEXT(vl)); VR(NEXT(vl)) = v; NEXT(NEXT(vl)) = 0;
331: MKV(v,t); *p = t;
332: return;
333: } else
334: vl = NEXT(vl);
335: }
336:
337: void makesrvar(f,p)
338: FUNC f;
339: P *p;
340: {
341: VL vl;
342: V v;
343: P t;
344: char *str;
345:
346: for ( vl = CO, str = NAME(f); ; )
347: if ( NAME(VR(vl)) && !strcmp(NAME(VR(vl)),str) ) {
348: VR(vl)->attr = (pointer)V_SR; VR(vl)->priv = (pointer)f;
349: MKV(VR(vl),t); *p = t;
350: return;
351: } else if ( !NEXT(vl) ) {
352: NEWV(v); v->attr = (pointer)V_SR; v->priv = (pointer)f;
353: NAME(v) = (char *)CALLOC(strlen(str)+1,sizeof(char));
354: strcpy(NAME(v),str);
355: NEWVL(NEXT(vl)); VR(NEXT(vl)) = v; NEXT(NEXT(vl)) = 0;
356: MKV(v,t); *p = t;
357: return;
358: } else
359: vl = NEXT(vl);
360: }
361:
362: void appendtonode(n,a,nrp)
363: NODE n;
364: pointer a;
365: NODE *nrp;
366: {
367: NODE tn;
368:
369: if ( !n )
370: MKNODE(*nrp,a,0);
371: else {
372: for ( tn = n; NEXT(tn); tn = NEXT(tn) );
373: MKNODE(NEXT(tn),a,0); *nrp = n;
374: }
375: }
376:
377: void appendtonode2(n,a,b,nrp)
378: NODE2 n;
379: pointer a,b;
380: NODE2 *nrp;
381: {
382: NODE2 tn;
383:
384: if ( !n )
385: MKNODE2(*nrp,a,b,0);
386: else {
387: for ( tn = n; NEXT(tn); tn = NEXT(tn) );
388: MKNODE2(NEXT(tn),a,b,0); *nrp = n;
389: }
390: }
391:
392: void appendvar(vl,v)
393: VL vl;
394: V v;
395: {
396: while (1)
397: if ( vl->v == v )
398: return;
399: else if ( !NEXT(vl) ) {
400: NEWVL(NEXT(vl)); VR(NEXT(vl)) = v; NEXT(NEXT(vl)) = 0;
401: return;
402: } else
403: vl = NEXT(vl);
404: }
405:
406: void reallocarray(arrayp,sizep,indexp,esize)
407: char **arrayp;
408: int *sizep,*indexp;
409: int esize;
410: {
411: char *new;
412:
413: if ( *arrayp ) {
414: *sizep *= 2;
415: new = (char *)MALLOC((*sizep)*esize);
416: bcopy(*arrayp,new,*indexp*esize);
417: *arrayp = new;
418: } else {
419: *sizep = DEFSIZE; *indexp = 0;
420: new = (char *)MALLOC((*sizep)*esize);
421: bzero(new,DEFSIZE*esize);
422: *arrayp = new;
423: }
424: }
425:
426: #if defined(THINK_C)
427: void bzero(p,len)
428: register char *p;
429: register int len;
430: {
431: for ( ; len; len-- )
432: *p++ = 0;
433: }
434:
435: void bcopy(s,d,len)
436: register char *s;
437: register char *d;
438: int len;
439: {
440: for ( ; len; len-- )
441: *d++ = *s++;
442: }
443:
444: char *index(char *s,char c)
445: {
446: for ( ; *s && *s != c; s++ );
447: if ( *s )
448: return s;
449: else
450: return 0;
451: }
452:
453: void printap(p)
454: P p;
455: {
456: DCP dc;
457:
458: for ( dc = DC(p); dc; dc = NEXT(dc) ) {
459: printf("(c=0x%lx c->nm=0x%lx c->nm->p=%ld) ",
460: (int *)dc->c,(int *)((Q)dc->c)->nm,(int)((Q)dc->c)->nm->p);
461: }
462: printf("\n");
463: }
464: #endif