![[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.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.3 ! noro 48: * $OpenXM: OpenXM_contrib2/asir2000/parse/util.c,v 1.2 2000/08/21 08:31:47 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;
127:
128: for ( ; ind; ind = NEXT(ind) ) {
129: if ( !a )
130: error("getarray : array or list expected");
131: switch ( OID(a) ) {
132: case O_VECT:
133: len = (Obj)BDY(ind);
134: if ( !rangecheck(len,((VECT)a)->len) )
135: error("getarray : Out of range");
136: else
137: a = (pointer)(BDY((VECT)a)[QTOS((Q)len)]);
138: break;
139: case O_MAT:
140: row = (Obj)BDY(ind);
141: if ( !rangecheck(row,((MAT)a)->row) )
142: error("getarray : Out of range");
143: else if ( NEXT(ind) ) {
144: ind = NEXT(ind);
145: col = (Obj)BDY(ind);
146: if ( !rangecheck(col,((MAT)a)->col) )
147: error("getarray : Out of range");
148: else
149: a = (pointer)(BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)]);
150: } else {
151: NEWVECT(v); v->len = ((MAT)a)->col;
152: v->body = (pointer *)BDY((MAT)a)[QTOS((Q)row)];
153: a = (pointer)v;
154: }
155: break;
156: case O_LIST:
157: n0 = BDY((LIST)a); i = QTOS((Q)BDY(ind));
158: for ( l = 0, n = n0; n; n = NEXT(n), l++ );
159: if ( i < 0 || i >= l )
160: error("getarray : Out of range");
161: else {
162: for ( n = n0, l = 0; l < i; l++, n = NEXT(n) );
163: a = (pointer)BDY(n);
164: }
165: break;
166: default:
167: error("getarray : array or list expected");
168: break;
169: }
170: }
171: *vp = a;
172: }
173:
174: void putarray(a,ind,b)
175: pointer a;
176: NODE ind;
177: pointer b;
178: {
179: Obj len,row,col;
180: int i,l;
181: NODE n,n0;
182:
183: for ( ; ind; ind = NEXT(ind) ) {
184: if ( !a )
185: error("putarray : array expected");
186: switch ( OID(a) ) {
187: case O_VECT:
188: len = (Obj)BDY(ind);
189: if ( !rangecheck(len,((VECT)a)->len) )
190: error("putarray : Out of range");
191: else if ( NEXT(ind) )
192: a = BDY((VECT)a)[QTOS((Q)len)];
193: else
194: BDY((VECT)a)[QTOS((Q)len)] = b;
195: break;
196: case O_MAT:
197: row = (Obj)BDY(ind);
198: if ( !rangecheck(row,((MAT)a)->row) )
199: error("putarray : Out of range");
200: else if ( NEXT(ind) ) {
201: ind = NEXT(ind);
202: col = (Obj)BDY(ind);
203: if ( !rangecheck(col,((MAT)a)->col) )
204: error("putarray : Out of range");
205: else if ( NEXT(ind) )
206: a = BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)];
207: else
208: BDY((MAT)a)[QTOS((Q)row)][QTOS((Q)col)] = b;
209: } else
210: error("putarray : invalid assignment");
211: break;
212: case O_LIST:
213: if ( NEXT(ind) ) {
214: n0 = BDY((LIST)a); i = QTOS((Q)BDY(ind));
215: for ( l = 0, n = n0; n; n = NEXT(n), l++ );
216: if ( i < 0 || i >= l )
217: error("putarray : Out of range");
218: else {
219: for ( n = n0, l = 0; l < i; l++, n = NEXT(n) );
220: a = (pointer)BDY(n);
221: }
222: } else
223: error("putarray : invalid assignment");
224: break;
225: default:
226: error("putarray : array expected");
227: break;
228: }
229: }
230: }
231:
232: int rangecheck(a,n)
233: Obj a;
234: int n;
235: {
236: N m;
237:
238: if ( !a )
239: return 1;
240: if ( OID(a) != O_N || !RATN(a) || !INT(a) || SGN((Q)a) < 0 )
241: return 0;
242: m = NM((Q)a);
243: if ( PL(m) > 1 || BD(m)[0] >= (unsigned int)n )
244: return 0;
245: return 1;
246: }
247:
248: int zp(p)
249: P p;
250: {
251: int r;
252: DCP dc;
253:
254: if ( !p )
255: r = 1;
256: else if ( NUM(p) )
257: r = INT((Q)p)?1:0;
258: else
259: for ( dc = DC(p), r = 1; dc && r; dc = NEXT(dc) )
260: r &= zp(COEF(dc));
261: return ( r );
262: }
263:
264: #if defined(THINK_C) || defined(VISUAL)
265: NODE mknode(int ac,...)
266: {
267: va_list ap;
268: int i;
269: NODE n0,n;
270:
271: va_start(ap,ac);
272: for ( i = 0, n0 = 0; i < ac; i++ ) {
273: NEXTNODE(n0,n);
274: BDY(n)=va_arg(ap, pointer);
275: }
276: va_end(ap);
277: if ( n0 )
278: NEXT(n)=0;
279: return n0;
280: }
281:
282: FNODE mkfnode(int ac,fid id,...)
283: {
284: va_list ap;
285: int i;
286: FNODE r;
287:
288: va_start(ap,id);
289: NEWFNODE(r,ac); ID(r) = id;
290: for ( i = 0; i < ac; i++ )
291: r->arg[i] = va_arg(ap, pointer);
292: va_end(ap);
293: return r;
294: }
295:
296: SNODE mksnode(int ac,sid id,...)
297: {
298: va_list ap;
299: int i;
300: SNODE r;
301:
302: va_start(ap,id);
303: NEWSNODE(r,ac); ID(r) = id;
304: for ( i = 0; i < ac; i++ )
305: r->arg[i] = va_arg(ap, pointer);
306: va_end(ap);
307: return r;
308: }
309: #else
310: NODE mknode(va_alist)
311: va_dcl
312: {
313: va_list ap;
314: int ac,i;
315: NODE n0,n;
316:
317: va_start(ap);
318: ac = va_arg(ap,int);
319: for ( i = 0, n0 = 0; i < ac; i++ ) {
320: NEXTNODE(n0,n);
321: BDY(n)=va_arg(ap, pointer);
322: }
323: va_end(ap);
324: if ( n0 )
325: NEXT(n)=0;
326: return n0;
327: }
328:
329: FNODE mkfnode(va_alist)
330: va_dcl
331: {
332: va_list ap;
333: int ac,i;
334: FNODE r;
335:
336: va_start(ap);
337: ac = va_arg(ap, int);
338: NEWFNODE(r,ac); ID(r) = va_arg(ap, fid);
339: for ( i = 0; i < ac; i++ )
340: r->arg[i] = va_arg(ap, pointer);
341: va_end(ap);
342: return r;
343: }
344:
345: SNODE mksnode(va_alist)
346: va_dcl
347: {
348: va_list ap;
349: int ac,i;
350: SNODE r;
351:
352: va_start(ap);
353: ac = va_arg(ap, int);
354: NEWSNODE(r,ac); ID(r) = va_arg(ap, sid);
355: for ( i = 0; i < ac; i++ )
356: r->arg[i] = va_arg(ap, pointer);
357: va_end(ap);
358: return r;
359: }
360: #endif
361:
362: void makevar(str,p)
363: char *str;
364: P *p;
365: {
366: VL vl;
367: V v;
368: P t;
369:
370: for ( vl = CO; ; )
371: if ( NAME(VR(vl)) && !strcmp(NAME(VR(vl)),str) ) {
372: MKV(VR(vl),t); *p = t;
373: return;
374: } else if ( !NEXT(vl) ) {
375: NEWV(v); v->attr = (pointer)V_IND;
376: NAME(v) = (char *)CALLOC(strlen(str)+1,sizeof(char));
377: strcpy(NAME(v),str);
378: NEWVL(NEXT(vl)); VR(NEXT(vl)) = v; NEXT(NEXT(vl)) = 0;
379: MKV(v,t); *p = t;
380: return;
381: } else
382: vl = NEXT(vl);
383: }
384:
385: void makesrvar(f,p)
386: FUNC f;
387: P *p;
388: {
389: VL vl;
390: V v;
391: P t;
392: char *str;
393:
394: for ( vl = CO, str = NAME(f); ; )
395: if ( NAME(VR(vl)) && !strcmp(NAME(VR(vl)),str) ) {
396: VR(vl)->attr = (pointer)V_SR; VR(vl)->priv = (pointer)f;
397: MKV(VR(vl),t); *p = t;
398: return;
399: } else if ( !NEXT(vl) ) {
400: NEWV(v); v->attr = (pointer)V_SR; v->priv = (pointer)f;
401: NAME(v) = (char *)CALLOC(strlen(str)+1,sizeof(char));
402: strcpy(NAME(v),str);
403: NEWVL(NEXT(vl)); VR(NEXT(vl)) = v; NEXT(NEXT(vl)) = 0;
404: MKV(v,t); *p = t;
405: return;
406: } else
407: vl = NEXT(vl);
408: }
409:
410: void appendtonode(n,a,nrp)
411: NODE n;
412: pointer a;
413: NODE *nrp;
414: {
415: NODE tn;
416:
417: if ( !n )
418: MKNODE(*nrp,a,0);
419: else {
420: for ( tn = n; NEXT(tn); tn = NEXT(tn) );
421: MKNODE(NEXT(tn),a,0); *nrp = n;
422: }
423: }
424:
425: void appendtonode2(n,a,b,nrp)
426: NODE2 n;
427: pointer a,b;
428: NODE2 *nrp;
429: {
430: NODE2 tn;
431:
432: if ( !n )
433: MKNODE2(*nrp,a,b,0);
434: else {
435: for ( tn = n; NEXT(tn); tn = NEXT(tn) );
436: MKNODE2(NEXT(tn),a,b,0); *nrp = n;
437: }
438: }
439:
440: void appendvar(vl,v)
441: VL vl;
442: V v;
443: {
444: while (1)
445: if ( vl->v == v )
446: return;
447: else if ( !NEXT(vl) ) {
448: NEWVL(NEXT(vl)); VR(NEXT(vl)) = v; NEXT(NEXT(vl)) = 0;
449: return;
450: } else
451: vl = NEXT(vl);
452: }
453:
454: void reallocarray(arrayp,sizep,indexp,esize)
455: char **arrayp;
456: int *sizep,*indexp;
457: int esize;
458: {
459: char *new;
460:
461: if ( *arrayp ) {
462: *sizep *= 2;
463: new = (char *)MALLOC((*sizep)*esize);
464: bcopy(*arrayp,new,*indexp*esize);
465: *arrayp = new;
466: } else {
467: *sizep = DEFSIZE; *indexp = 0;
468: new = (char *)MALLOC((*sizep)*esize);
469: bzero(new,DEFSIZE*esize);
470: *arrayp = new;
471: }
472: }
473:
474: #if defined(THINK_C)
475: void bzero(p,len)
476: register char *p;
477: register int len;
478: {
479: for ( ; len; len-- )
480: *p++ = 0;
481: }
482:
483: void bcopy(s,d,len)
484: register char *s;
485: register char *d;
486: int len;
487: {
488: for ( ; len; len-- )
489: *d++ = *s++;
490: }
491:
492: char *index(char *s,char c)
493: {
494: for ( ; *s && *s != c; s++ );
495: if ( *s )
496: return s;
497: else
498: return 0;
499: }
500:
501: void printap(p)
502: P p;
503: {
504: DCP dc;
505:
506: for ( dc = DC(p); dc; dc = NEXT(dc) ) {
507: printf("(c=0x%lx c->nm=0x%lx c->nm->p=%ld) ",
508: (int *)dc->c,(int *)((Q)dc->c)->nm,(int)((Q)dc->c)->nm->p);
509: }
510: printf("\n");
511: }
512: #endif