src/cv/trans.c

/* Copyright (c) 1990 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 * Translator utilities
 *
 *      Greg Ward
 */

#include <stdio.h>

#include "trans.h"


fgetid(idp, dls, fp)            /* read an id up to char in dls from fp */
register ID     *idp;
char    *dls;
FILE    *fp;
{
        char    dset[256/8];
        char    buf[MAXSTR];
        register int    c;
        register char   *cp;
                                        /* create delimiter set */
        for (cp = dset+sizeof(dset); cp-- > dset; )
                *cp = 0;
        for (cp = dls; *cp; cp++)
                dset[*cp>>3] |= 1<<(*cp&7);
                                        /* get characters up to delimiter */
        cp = buf;
        while ((c = getc(fp)) != EOF && !(dset[c>>3] & 1<<(c&7)))
                *cp++ = c;
                                        /* check for empty */
        if (cp == buf) {
                if (c == EOF)
                        return(EOF);
                idp->number = 0;
                idp->name = NULL;
                return(0);
        }
                                        /* truncate space at end */
        while (cp[-1] == ' ' || cp[-1] == '\t')
                cp--;
        *cp = '\0';
                                        /* skip white space at beginning */
        for (cp = buf; *cp && (*cp == ' ' || *cp == '\t'); cp++)
                ;
                                        /* assign value */
        idp->number = atoi(cp);
        idp->name = NULL;
                                        /* check for ghost string */
        if (!*cp)
                return(0);
                                        /* check for name */
        if (idp->number == 0 && *cp != '0')
                idp->name = savestr(cp);
        return(0);
}


int
findid(idl, idp, insert)                /* find (or insert) id in list */
register IDLIST *idl;
ID      *idp;
int     insert;
{
        int  upper, lower;
        register int  cm, i;
                                        /* binary search */
        lower = 0;
        upper = cm = idl->nids;
        while ((i = (lower + upper) >> 1) != cm) {
                cm = idcmp(idp, &idl->id[i]);
                if (cm > 0)
                        lower = i;
                else if (cm < 0)
                        upper = i;
                else
                        return(i);
                cm = i;
        }
        if (!insert)
                return(-1);
        if (idl->nids == 0) {                   /* create new list */
                idl->id = (ID *)malloc(sizeof(ID));
                if (idl->id == NULL)
                        goto memerr;
        } else {                                /* grow old list */
                idl->id = (ID *)realloc((char *)idl->id,(idl->nids+1)*sizeof(ID));
                if (idl->id == NULL)
                        goto memerr;
                for (i = idl->nids; i > upper; i--) {
                        idl->id[i].number = idl->id[i-1].number;
                        idl->id[i].name = idl->id[i-1].name;
                }
        }
        idl->nids++;                            /* insert new element */
        idl->id[i].number = idp->number;
        if (idp->name == NULL)
                idl->id[i].name = NULL;
        else
                idl->id[i].name = savestr(idp->name);
        return(i);
memerr:
        eputs("Out of memory in findid\n");
        quit(1);
}


int
idcmp(id1, id2)                         /* compare two identifiers */
register ID     *id1, *id2;
{
                                        /* names are greater than numbers */
        if (id1->name == NULL)
                if (id2->name == NULL)
                        return(id1->number - id2->number);
                else
                        return(-1);
        else
                if (id2->name == NULL)
                        return(1);
                else
                        return(strcmp(id1->name, id2->name));
}


write_quals(qlp, idl, fp)       /* write out qualifier lists */
QLIST   *qlp;
IDLIST  idl[];
FILE    *fp;
{
        int     i;
        
        for (i = 0; i < qlp->nquals; i++)
                if (idl[i].nids > 0) {
                        fprintf(fp, "qualifier %s begin\n", qlp->qual[i]);
                        fputidlist(&idl[i], fp);
                        fprintf(fp, "end\n");
                }
}


fputidlist(qp, fp)              /* put id list out to fp */
IDLIST  *qp;
FILE    *fp;
{
        int     fi;
        register int    i;
                                        /* print numbers/ranges */
        fi = 0;
        for (i = 0; i < qp->nids && qp->id[i].name == NULL; i++)
                if (i > 0 && qp->id[i].number > qp->id[i-1].number+1) {
                        if (i > fi+1)
                                fprintf(fp, "[%d:%d]\n", qp->id[fi].number,
                                                qp->id[i-1].number);
                        else
                                fprintf(fp, "%d\n", qp->id[fi].number);
                        fi = i;
                }
        if (i-1 > fi)
                fprintf(fp, "[%d:%d]\n", qp->id[fi].number,
                                qp->id[i-1].number);
        else if (i > 0)
                fprintf(fp, "%d\n", qp->id[fi].number);
        for ( ; i < qp->nids; i++)
                fprintf(fp, "\"%s\"\n", qp->id[i].name);
}


RULEHD *
getmapping(file, qlp)           /* read in mapping file */
char    *file;
QLIST   *qlp;
{
        char    *err;
        register int    c;
        RULEHD  *mp = NULL;
        int     nrules = 0;
        register RULEHD *rp;
        register int    qt;
        char    buf[MAXSTR];
        FILE    *fp;
        
        if ((fp = fopen(file, "r")) == NULL) {
                eputs(file);
                eputs(": cannot open\n");
                quit(1);
        }
                                                        /* get each rule */
        while (fscanf(fp, " %[^         ;\n]", buf) == 1) {
                if (buf[0] == '#') {                    /* comment */
                        while ((c = getc(fp)) != EOF && c != '\n')
                                ;
                        continue;
                }
                rp = (RULEHD *)calloc(1, rulsiz(qlp->nquals));
                if (rp == NULL)
                        goto memerr;
                rp->mnam = savestr(buf);
                for ( ; ; ) {                           /* get conditions */
                        while ((c = getc(fp)) != '(')
                                if (c == ';' || c == EOF)
                                        goto endloop;
                        if (fscanf(fp, " %s ", buf) != 1) {
                                err = "missing variable";
                                goto fmterr;
                        }
                        if ((qt = qtype(buf, qlp)) == -1) {
                                err = "unknown variable";
                                goto fmterr;
                        }
                        if (rp->qflg & FL(qt)) {
                                err = "variable repeated";
                                goto fmterr;
                        }
                        rp->qflg |= FL(qt);
                        c = getc(fp);
                        switch (c) {
                        case '"':                       /* id name */
                                if (fscanf(fp, "%[^\"]\" )", buf) != 1) {
                                        err = "bad string value";
                                        goto fmterr;
                                }
                                idm(rp)[qt].nam = savestr(buf);
                                break;
                        case '[':                       /* id range */
                                if (fscanf(fp, "%d : %d ] )", &idm(rp)[qt].min,
                                                &idm(rp)[qt].max) != 2) {
                                        err = "bad range value";
                                        goto fmterr;
                                }
                                if (idm(rp)[qt].min > idm(rp)[qt].max) {
                                        err = "reverse range value";
                                        goto fmterr;
                                }
                                break;
                        default:                        /* id number? */
                                if ((c < '0' || c > '9') && c != '-') {
                                        err = "unrecognizable value";
                                        goto fmterr;
                                }
                                ungetc(c, fp);
                                if (fscanf(fp, "%d )", &idm(rp)[qt].min) != 1) {
                                        err = "bad number id";
                                        goto fmterr;
                                }
                                idm(rp)[qt].max = idm(rp)[qt].min;
                                break;
                        }
                }
        endloop:
                rp->next = mp;
                mp = rp;
                nrules++;
        }
        fclose(fp);
        return(mp);
fmterr:
        sprintf(buf, "%s: %s for rule %d\n", file, err, nrules+1);
        eputs(buf);
        quit(1);
memerr:
        eputs("Out of memory in getmapping\n");
        quit(1);
}


int
qtype(qnm, qlp)                 /* return number for qualifier name */
char    *qnm;
register QLIST  *qlp;
{
        register int    i;
        
        for (i = 0; i < qlp->nquals; i++)
                if (!strcmp(qnm, qlp->qual[i]))
                        return(i);
        return(-1);
}


matchid(it, im)                 /* see if we match an id */
register ID     *it;
register IDMATCH        *im;
{
        if (it->name == NULL) {
                if (im->nam != NULL)
                        return(0);
                return(it->number >= im->min && it->number <= im->max);
        }
        if (im->nam == NULL)
                return(0);
        return(!strcmp(it->name, im->nam));
}
Revision:	1.1
Committed:	Tue Dec 11 08:45:51 1990 UTC (34 years, 10 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Log Message:	Initial revision
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1990 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* Translator utilities
9			*
10			* Greg Ward
11			*/
12
13			#include <stdio.h>
14
15			#include "trans.h"
16
17
18			fgetid(idp, dls, fp) /* read an id up to char in dls from fp */
19			register ID *idp;
20			char *dls;
21			FILE *fp;
22			{
23			char dset[256/8];
24			char buf[MAXSTR];
25			register int c;
26			register char *cp;
27			/* create delimiter set */
28			for (cp = dset+sizeof(dset); cp-- > dset; )
29			*cp = 0;
30			for (cp = dls; *cp; cp++)
31			dset[cp>>3] \|= 1<<(cp&7);
32			/* get characters up to delimiter */
33			cp = buf;
34			while ((c = getc(fp)) != EOF && !(dset[c>>3] & 1<<(c&7)))
35			*cp++ = c;
36			/* check for empty */
37			if (cp == buf) {
38			if (c == EOF)
39			return(EOF);
40			idp->number = 0;
41			idp->name = NULL;
42			return(0);
43			}
44			/* truncate space at end */
45			while (cp[-1] == ' ' \|\| cp[-1] == '\t')
46			cp--;
47			*cp = '\0';
48			/* skip white space at beginning */
49			for (cp = buf; cp && (cp == ' ' \|\| *cp == '\t'); cp++)
50			;
51			/* assign value */
52			idp->number = atoi(cp);
53			idp->name = NULL;
54			/* check for ghost string */
55			if (!*cp)
56			return(0);
57			/* check for name */
58			if (idp->number == 0 && *cp != '0')
59			idp->name = savestr(cp);
60			return(0);
61			}
62
63
64			int
65			findid(idl, idp, insert) /* find (or insert) id in list */
66			register IDLIST *idl;
67			ID *idp;
68			int insert;
69			{
70			int upper, lower;
71			register int cm, i;
72			/* binary search */
73			lower = 0;
74			upper = cm = idl->nids;
75			while ((i = (lower + upper) >> 1) != cm) {
76			cm = idcmp(idp, &idl->id[i]);
77			if (cm > 0)
78			lower = i;
79			else if (cm < 0)
80			upper = i;
81			else
82			return(i);
83			cm = i;
84			}
85			if (!insert)
86			return(-1);
87			if (idl->nids == 0) { /* create new list */
88			idl->id = (ID *)malloc(sizeof(ID));
89			if (idl->id == NULL)
90			goto memerr;
91			} else { /* grow old list */
92			idl->id = (ID )realloc((char )idl->id,(idl->nids+1)*sizeof(ID));
93			if (idl->id == NULL)
94			goto memerr;
95			for (i = idl->nids; i > upper; i--) {
96			idl->id[i].number = idl->id[i-1].number;
97			idl->id[i].name = idl->id[i-1].name;
98			}
99			}
100			idl->nids++; /* insert new element */
101			idl->id[i].number = idp->number;
102			if (idp->name == NULL)
103			idl->id[i].name = NULL;
104			else
105			idl->id[i].name = savestr(idp->name);
106			return(i);
107			memerr:
108			eputs("Out of memory in findid\n");
109			quit(1);
110			}
111
112
113			int
114			idcmp(id1, id2) /* compare two identifiers */
115			register ID id1, id2;
116			{
117			/* names are greater than numbers */
118			if (id1->name == NULL)
119			if (id2->name == NULL)
120			return(id1->number - id2->number);
121			else
122			return(-1);
123			else
124			if (id2->name == NULL)
125			return(1);
126			else
127			return(strcmp(id1->name, id2->name));
128			}
129
130
131			write_quals(qlp, idl, fp) /* write out qualifier lists */
132			QLIST *qlp;
133			IDLIST idl[];
134			FILE *fp;
135			{
136			int i;
137
138			for (i = 0; i < qlp->nquals; i++)
139			if (idl[i].nids > 0) {
140			fprintf(fp, "qualifier %s begin\n", qlp->qual[i]);
141			fputidlist(&idl[i], fp);
142			fprintf(fp, "end\n");
143			}
144			}
145
146
147			fputidlist(qp, fp) /* put id list out to fp */
148			IDLIST *qp;
149			FILE *fp;
150			{
151			int fi;
152			register int i;
153			/* print numbers/ranges */
154			fi = 0;
155			for (i = 0; i < qp->nids && qp->id[i].name == NULL; i++)
156			if (i > 0 && qp->id[i].number > qp->id[i-1].number+1) {
157			if (i > fi+1)
158			fprintf(fp, "[%d:%d]\n", qp->id[fi].number,
159			qp->id[i-1].number);
160			else
161			fprintf(fp, "%d\n", qp->id[fi].number);
162			fi = i;
163			}
164			if (i-1 > fi)
165			fprintf(fp, "[%d:%d]\n", qp->id[fi].number,
166			qp->id[i-1].number);
167			else if (i > 0)
168			fprintf(fp, "%d\n", qp->id[fi].number);
169			for ( ; i < qp->nids; i++)
170			fprintf(fp, "\"%s\"\n", qp->id[i].name);
171			}
172
173
174			RULEHD *
175			getmapping(file, qlp) /* read in mapping file */
176			char *file;
177			QLIST *qlp;
178			{
179			char *err;
180			register int c;
181			RULEHD *mp = NULL;
182			int nrules = 0;
183			register RULEHD *rp;
184			register int qt;
185			char buf[MAXSTR];
186			FILE *fp;
187
188			if ((fp = fopen(file, "r")) == NULL) {
189			eputs(file);
190			eputs(": cannot open\n");
191			quit(1);
192			}
193			/* get each rule */
194			while (fscanf(fp, " %[^ ;\n]", buf) == 1) {
195			if (buf[0] == '#') { /* comment */
196			while ((c = getc(fp)) != EOF && c != '\n')
197			;
198			continue;
199			}
200			rp = (RULEHD *)calloc(1, rulsiz(qlp->nquals));
201			if (rp == NULL)
202			goto memerr;
203			rp->mnam = savestr(buf);
204			for ( ; ; ) { /* get conditions */
205			while ((c = getc(fp)) != '(')
206			if (c == ';' \|\| c == EOF)
207			goto endloop;
208			if (fscanf(fp, " %s ", buf) != 1) {
209			err = "missing variable";
210			goto fmterr;
211			}
212			if ((qt = qtype(buf, qlp)) == -1) {
213			err = "unknown variable";
214			goto fmterr;
215			}
216			if (rp->qflg & FL(qt)) {
217			err = "variable repeated";
218			goto fmterr;
219			}
220			rp->qflg \|= FL(qt);
221			c = getc(fp);
222			switch (c) {
223			case '"': /* id name */
224			if (fscanf(fp, "%[^\"]\" )", buf) != 1) {
225			err = "bad string value";
226			goto fmterr;
227			}
228			idm(rp)[qt].nam = savestr(buf);
229			break;
230			case '[': /* id range */
231			if (fscanf(fp, "%d : %d ] )", &idm(rp)[qt].min,
232			&idm(rp)[qt].max) != 2) {
233			err = "bad range value";
234			goto fmterr;
235			}
236			if (idm(rp)[qt].min > idm(rp)[qt].max) {
237			err = "reverse range value";
238			goto fmterr;
239			}
240			break;
241			default: /* id number? */
242			if ((c < '0' \|\| c > '9') && c != '-') {
243			err = "unrecognizable value";
244			goto fmterr;
245			}
246			ungetc(c, fp);
247			if (fscanf(fp, "%d )", &idm(rp)[qt].min) != 1) {
248			err = "bad number id";
249			goto fmterr;
250			}
251			idm(rp)[qt].max = idm(rp)[qt].min;
252			break;
253			}
254			}
255			endloop:
256			rp->next = mp;
257			mp = rp;
258			nrules++;
259			}
260			fclose(fp);
261			return(mp);
262			fmterr:
263			sprintf(buf, "%s: %s for rule %d\n", file, err, nrules+1);
264			eputs(buf);
265			quit(1);
266			memerr:
267			eputs("Out of memory in getmapping\n");
268			quit(1);
269			}
270
271
272			int
273			qtype(qnm, qlp) /* return number for qualifier name */
274			char *qnm;
275			register QLIST *qlp;
276			{
277			register int i;
278
279			for (i = 0; i < qlp->nquals; i++)
280			if (!strcmp(qnm, qlp->qual[i]))
281			return(i);
282			return(-1);
283			}
284
285
286			matchid(it, im) /* see if we match an id */
287			register ID *it;
288			register IDMATCH *im;
289			{
290			if (it->name == NULL) {
291			if (im->nam != NULL)
292			return(0);
293			return(it->number >= im->min && it->number <= im->max);
294			}
295			if (im->nam == NULL)
296			return(0);
297			return(!strcmp(it->name, im->nam));
298			}