Annotation of OpenXM_contrib2/asir2000/parse/util.c, Revision 1.4
1.2 noro 1: /*
2: * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
3: * All rights reserved.
4: *
5: * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
6: * non-exclusive and royalty-free license to use, copy, modify and
7: * redistribute, solely for non-commercial and non-profit purposes, the
8: * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
9: * conditions of this Agreement. For the avoidance of doubt, you acquire
10: * only a limited right to use the SOFTWARE hereunder, and FLL or any
11: * third party developer retains all rights, including but not limited to
12: * copyrights, in and to the SOFTWARE.
13: *
14: * (1) FLL does not grant you a license in any way for commercial
15: * purposes. You may use the SOFTWARE only for non-commercial and
16: * non-profit purposes only, such as academic, research and internal
17: * business use.
18: * (2) The SOFTWARE is protected by the Copyright Law of Japan and
19: * international copyright treaties. If you make copies of the SOFTWARE,
20: * with or without modification, as permitted hereunder, you shall affix
21: * to all such copies of the SOFTWARE the above copyright notice.
22: * (3) An explicit reference to this SOFTWARE and its copyright owner
23: * shall be made on your publication or presentation in any form of the
24: * results obtained by use of the SOFTWARE.
25: * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
1.3 noro 26: * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
1.2 noro 27: * for such modification or the source code of the modified part of the
28: * SOFTWARE.
29: *
30: * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
31: * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
32: * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
33: * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
34: * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
35: * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
36: * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
37: * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
38: * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
39: * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
40: * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
41: * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
42: * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
43: * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
44: * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
45: * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
46: * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
47: *
1.4 ! noro 48: * $OpenXM: OpenXM_contrib2/asir2000/parse/util.c,v 1.3 2000/08/22 05:04:28 noro Exp $
1.2 noro 49: */
1.1 noro 50: #include "ca.h"
51: #include "base.h"
52: #include "parse.h"
53: #if defined(THINK_C) || defined(VISUAL)
54: #include <stdarg.h>
55: #else
56: #include <varargs.h>
57: #endif
58: #include <ctype.h>
59:
60: int length(n)
61: NODE n;
62: {
63: int i;
64:
65: for ( i = 0; n; n = NEXT(n), i++ );
66: return i;
67: }
68:
69: int argc(a)
70: NODE a;
71: {
72: int i;
73:
74: for ( i = 0; a; i++, a = NEXT(a) );
75: return ( i );
76: }
77:
78: void stoarg(s,acp,av)
79: char *s;
80: int *acp;
81: char **av;
82: {
83: int i;
84:
85: for ( i = 0; ; i++ ) {
86: for ( ; *s && isspace(*s); s++ );
87: if ( *s ) {
88: for ( av[i] = s; *s && !isspace(*s); s++ );
89: if ( *s )
90: *s++ = 0;
91: } else {
92: *acp = i;
93: return;
94: }
95: }
96: }
97:
98: #if 0
99: unsigned int ator(addr,r)
100: unsigned int addr;
101: Obj *r;
102: {
103: N n;
104: Q q;
105:
106: if ( !addr )
107: q = 0;
108: if ( addr < BASE )
109: STOQ(addr,q);
110: else {
111: n = NALLOC(2); PL(n) = 2;
112: BD(n)[0] = addr-BASE; BD(n)[1] = addr>>BSH; NTOQ(n,1,q);
113: }
114: *r = (Obj)q;
115: }
116: #endif
117:
118: void getarray(a,ind,vp)
119: pointer a;
120: NODE ind;
121: pointer *vp;
122: {
123: Obj len,row,col;
124: int i,l;
125: NODE n,n0;
126: VECT v;
1.4 ! noro 127: Q q;
1.1 noro 128:
1.4 ! noro 129: if ( a && OID(a) == O_BYTEARRAY ) {
! 130: len = (Obj)BDY(ind);
! 131: if ( !rangecheck(len,((BYTEARRAY)a)->len) )
! 132: error("getarray : Out of range");
! 133: else if ( NEXT(ind) )
! 134: error("getarray : invalid index");
! 135: else {
! 136: i = (int)BDY((BYTEARRAY)a)[QTOS((Q)len)];
! 137: STOQ(i,q);
! 138: *vp = (pointer)q;
! 139: }
! 140: return;
! 141: }
1.1 noro 142: for ( ; ind; ind = NEXT(ind) ) {
143: if ( !a )
144: error("getarray : array or list expected");
145: switch ( OID(a) ) {
146: case O_VECT:
147: len = (Obj)BDY(ind);
148: if ( !rangecheck(len,((VECT)a)->len) )
149: error("getarray : Out of range");
150: else
151: a = (pointer)(BDY((VECT)a)[QTOS((Q)len)]);
152: break;
153: case O_MAT:
154: row = (Obj)BDY(ind);
155: if ( !rangecheck(row,((MAT)a)->row) )
156: error("getarray : Out of range");
157: else if ( NEXT(ind) ) {
158: ind = NEXT(ind);
159: col = (Obj)BDY(ind);
160: if ( !rangecheck(col,((MAT)a)->col) )
161: error("getarray : Out of range");
162: else
163: a = (pointer)(BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)]);
164: } else {
165: NEWVECT(v); v->len = ((MAT)a)->col;
166: v->body = (pointer *)BDY((MAT)a)[QTOS((Q)row)];
167: a = (pointer)v;
168: }
169: break;
170: case O_LIST:
171: n0 = BDY((LIST)a); i = QTOS((Q)BDY(ind));
172: for ( l = 0, n = n0; n; n = NEXT(n), l++ );
173: if ( i < 0 || i >= l )
174: error("getarray : Out of range");
175: else {
176: for ( n = n0, l = 0; l < i; l++, n = NEXT(n) );
177: a = (pointer)BDY(n);
178: }
179: break;
180: default:
181: error("getarray : array or list expected");
182: break;
183: }
184: }
185: *vp = a;
186: }
187:
188: void putarray(a,ind,b)
189: pointer a;
190: NODE ind;
191: pointer b;
192: {
193: Obj len,row,col;
194: int i,l;
195: NODE n,n0;
196:
1.4 ! noro 197: if ( a && OID(a) == O_BYTEARRAY ) {
! 198: len = (Obj)BDY(ind);
! 199: if ( !rangecheck(len,((BYTEARRAY)a)->len) )
! 200: error("putarray : Out of range");
! 201: else if ( NEXT(ind) )
! 202: error("putarray : invalid index");
! 203: else
! 204: BDY((BYTEARRAY)a)[QTOS((Q)len)] = (unsigned char)QTOS((Q)b);
! 205: return;
! 206: }
1.1 noro 207: for ( ; ind; ind = NEXT(ind) ) {
208: if ( !a )
209: error("putarray : array expected");
210: switch ( OID(a) ) {
211: case O_VECT:
212: len = (Obj)BDY(ind);
213: if ( !rangecheck(len,((VECT)a)->len) )
214: error("putarray : Out of range");
215: else if ( NEXT(ind) )
216: a = BDY((VECT)a)[QTOS((Q)len)];
217: else
218: BDY((VECT)a)[QTOS((Q)len)] = b;
219: break;
220: case O_MAT:
221: row = (Obj)BDY(ind);
222: if ( !rangecheck(row,((MAT)a)->row) )
223: error("putarray : Out of range");
224: else if ( NEXT(ind) ) {
225: ind = NEXT(ind);
226: col = (Obj)BDY(ind);
227: if ( !rangecheck(col,((MAT)a)->col) )
228: error("putarray : Out of range");
229: else if ( NEXT(ind) )
230: a = BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)];
231: else
232: BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)] = b;
233: } else
234: error("putarray : invalid assignment");
235: break;
236: case O_LIST:
237: if ( NEXT(ind) ) {
238: n0 = BDY((LIST)a); i = QTOS((Q)BDY(ind));
239: for ( l = 0, n = n0; n; n = NEXT(n), l++ );
240: if ( i < 0 || i >= l )
241: error("putarray : Out of range");
242: else {
243: for ( n = n0, l = 0; l < i; l++, n = NEXT(n) );
244: a = (pointer)BDY(n);
245: }
246: } else
247: error("putarray : invalid assignment");
248: break;
249: default:
250: error("putarray : array expected");
251: break;
252: }
253: }
254: }
255:
256: int rangecheck(a,n)
257: Obj a;
258: int n;
259: {
260: N m;
261:
262: if ( !a )
263: return 1;
264: if ( OID(a) != O_N || !RATN(a) || !INT(a) || SGN((Q)a) < 0 )
265: return 0;
266: m = NM((Q)a);
267: if ( PL(m) > 1 || BD(m)[0] >= (unsigned int)n )
268: return 0;
269: return 1;
270: }
271:
272: int zp(p)
273: P p;
274: {
275: int r;
276: DCP dc;
277:
278: if ( !p )
279: r = 1;
280: else if ( NUM(p) )
281: r = INT((Q)p)?1:0;
282: else
283: for ( dc = DC(p), r = 1; dc && r; dc = NEXT(dc) )
284: r &= zp(COEF(dc));
285: return ( r );
286: }
287:
288: #if defined(THINK_C) || defined(VISUAL)
289: NODE mknode(int ac,...)
290: {
291: va_list ap;
292: int i;
293: NODE n0,n;
294:
295: va_start(ap,ac);
296: for ( i = 0, n0 = 0; i < ac; i++ ) {
297: NEXTNODE(n0,n);
298: BDY(n)=va_arg(ap, pointer);
299: }
300: va_end(ap);
301: if ( n0 )
302: NEXT(n)=0;
303: return n0;
304: }
305:
306: FNODE mkfnode(int ac,fid id,...)
307: {
308: va_list ap;
309: int i;
310: FNODE r;
311:
312: va_start(ap,id);
313: NEWFNODE(r,ac); ID(r) = id;
314: for ( i = 0; i < ac; i++ )
315: r->arg[i] = va_arg(ap, pointer);
316: va_end(ap);
317: return r;
318: }
319:
320: SNODE mksnode(int ac,sid id,...)
321: {
322: va_list ap;
323: int i;
324: SNODE r;
325:
326: va_start(ap,id);
327: NEWSNODE(r,ac); ID(r) = id;
328: for ( i = 0; i < ac; i++ )
329: r->arg[i] = va_arg(ap, pointer);
330: va_end(ap);
331: return r;
332: }
333: #else
334: NODE mknode(va_alist)
335: va_dcl
336: {
337: va_list ap;
338: int ac,i;
339: NODE n0,n;
340:
341: va_start(ap);
342: ac = va_arg(ap,int);
343: for ( i = 0, n0 = 0; i < ac; i++ ) {
344: NEXTNODE(n0,n);
345: BDY(n)=va_arg(ap, pointer);
346: }
347: va_end(ap);
348: if ( n0 )
349: NEXT(n)=0;
350: return n0;
351: }
352:
353: FNODE mkfnode(va_alist)
354: va_dcl
355: {
356: va_list ap;
357: int ac,i;
358: FNODE r;
359:
360: va_start(ap);
361: ac = va_arg(ap, int);
362: NEWFNODE(r,ac); ID(r) = va_arg(ap, fid);
363: for ( i = 0; i < ac; i++ )
364: r->arg[i] = va_arg(ap, pointer);
365: va_end(ap);
366: return r;
367: }
368:
369: SNODE mksnode(va_alist)
370: va_dcl
371: {
372: va_list ap;
373: int ac,i;
374: SNODE r;
375:
376: va_start(ap);
377: ac = va_arg(ap, int);
378: NEWSNODE(r,ac); ID(r) = va_arg(ap, sid);
379: for ( i = 0; i < ac; i++ )
380: r->arg[i] = va_arg(ap, pointer);
381: va_end(ap);
382: return r;
383: }
384: #endif
385:
386: void makevar(str,p)
387: char *str;
388: P *p;
389: {
390: VL vl;
391: V v;
392: P t;
393:
394: for ( vl = CO; ; )
395: if ( NAME(VR(vl)) && !strcmp(NAME(VR(vl)),str) ) {
396: MKV(VR(vl),t); *p = t;
397: return;
398: } else if ( !NEXT(vl) ) {
399: NEWV(v); v->attr = (pointer)V_IND;
400: NAME(v) = (char *)CALLOC(strlen(str)+1,sizeof(char));
401: strcpy(NAME(v),str);
402: NEWVL(NEXT(vl)); VR(NEXT(vl)) = v; NEXT(NEXT(vl)) = 0;
403: MKV(v,t); *p = t;
404: return;
405: } else
406: vl = NEXT(vl);
407: }
408:
409: void makesrvar(f,p)
410: FUNC f;
411: P *p;
412: {
413: VL vl;
414: V v;
415: P t;
416: char *str;
417:
418: for ( vl = CO, str = NAME(f); ; )
419: if ( NAME(VR(vl)) && !strcmp(NAME(VR(vl)),str) ) {
420: VR(vl)->attr = (pointer)V_SR; VR(vl)->priv = (pointer)f;
421: MKV(VR(vl),t); *p = t;
422: return;
423: } else if ( !NEXT(vl) ) {
424: NEWV(v); v->attr = (pointer)V_SR; v->priv = (pointer)f;
425: NAME(v) = (char *)CALLOC(strlen(str)+1,sizeof(char));
426: strcpy(NAME(v),str);
427: NEWVL(NEXT(vl)); VR(NEXT(vl)) = v; NEXT(NEXT(vl)) = 0;
428: MKV(v,t); *p = t;
429: return;
430: } else
431: vl = NEXT(vl);
432: }
433:
434: void appendtonode(n,a,nrp)
435: NODE n;
436: pointer a;
437: NODE *nrp;
438: {
439: NODE tn;
440:
441: if ( !n )
442: MKNODE(*nrp,a,0);
443: else {
444: for ( tn = n; NEXT(tn); tn = NEXT(tn) );
445: MKNODE(NEXT(tn),a,0); *nrp = n;
446: }
447: }
448:
449: void appendtonode2(n,a,b,nrp)
450: NODE2 n;
451: pointer a,b;
452: NODE2 *nrp;
453: {
454: NODE2 tn;
455:
456: if ( !n )
457: MKNODE2(*nrp,a,b,0);
458: else {
459: for ( tn = n; NEXT(tn); tn = NEXT(tn) );
460: MKNODE2(NEXT(tn),a,b,0); *nrp = n;
461: }
462: }
463:
464: void appendvar(vl,v)
465: VL vl;
466: V v;
467: {
468: while (1)
469: if ( vl->v == v )
470: return;
471: else if ( !NEXT(vl) ) {
472: NEWVL(NEXT(vl)); VR(NEXT(vl)) = v; NEXT(NEXT(vl)) = 0;
473: return;
474: } else
475: vl = NEXT(vl);
476: }
477:
478: void reallocarray(arrayp,sizep,indexp,esize)
479: char **arrayp;
480: int *sizep,*indexp;
481: int esize;
482: {
483: char *new;
484:
485: if ( *arrayp ) {
486: *sizep *= 2;
487: new = (char *)MALLOC((*sizep)*esize);
488: bcopy(*arrayp,new,*indexp*esize);
489: *arrayp = new;
490: } else {
491: *sizep = DEFSIZE; *indexp = 0;
492: new = (char *)MALLOC((*sizep)*esize);
493: bzero(new,DEFSIZE*esize);
494: *arrayp = new;
495: }
496: }
497:
498: #if defined(THINK_C)
499: void bzero(p,len)
500: register char *p;
501: register int len;
502: {
503: for ( ; len; len-- )
504: *p++ = 0;
505: }
506:
507: void bcopy(s,d,len)
508: register char *s;
509: register char *d;
510: int len;
511: {
512: for ( ; len; len-- )
513: *d++ = *s++;
514: }
515:
516: char *index(char *s,char c)
517: {
518: for ( ; *s && *s != c; s++ );
519: if ( *s )
520: return s;
521: else
522: return 0;
523: }
524:
525: void printap(p)
526: P p;
527: {
528: DCP dc;
529:
530: for ( dc = DC(p); dc; dc = NEXT(dc) ) {
531: printf("(c=0x%lx c->nm=0x%lx c->nm->p=%ld) ",
532: (int *)dc->c,(int *)((Q)dc->c)->nm,(int)((Q)dc->c)->nm->p);
533: }
534: printf("\n");
535: }
536: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>