Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 1 
#include <stdio.h>
2 
#include <string.h>
3 
#include <stdlib.h>
4 
#include "grap.h"
5 
#include "y.tab.h"
6 
 
7 
int	nnum	= 0;	/* number of saved numbers */
8 
double	num[MAXNUM];
9 
 
10 
int	just;		/* current justification mode (RJUST, etc.) */
11 
int	sizeop;		/* current optional operator for size change */
12 
double	sizexpr;	/* current size change expression */
13 
 
14 
void savenum(int n, double f)	/* save f in num[n] */
15 
{
16 
	num[n] = f;
17 
	nnum = n+1;
18 
	if (nnum >= MAXNUM)
19 
		ERROR "too many numbers" WARNING;
20 
}
21 
 
22 
void setjust(int j)
23 
{
24 
	just |= j;
25 
}
26 
 
27 
void setsize(int op, double expr)
28 
{
29 
	sizeop = op;
30 
	sizexpr = expr;
31 
}
32 
 
33 
char *tostring(char *s)
34 
{
35 
	register char *p;
36 
 
37 
	p = malloc(strlen(s)+1);
38 
	if (p == NULL)
39 
		ERROR "out of space in tostring on %s", s FATAL;
40 
	strcpy(p, s);
41 
	return(p);
42 
}
43 
 
44 
void range(Point pt)	/* update the range for point pt */
45 
{
46 
	Obj *p = pt.obj;
47 
 
48 
	if (!(p->coord & XFLAG)) {
49 
		if (pt.x > p->pt1.x)
50 
			p->pt1.x = pt.x;
51 
		if (pt.x < p->pt.x)
52 
			p->pt.x = pt.x;
53 
	}
54 
	if (!(p->coord & YFLAG)) {
55 
		if (pt.y > p->pt1.y)
56 
			p->pt1.y = pt.y;
57 
		if (pt.y < p->pt.y)
58 
			p->pt.y = pt.y;
59 
	}
60 
}
61 
 
62 
void halfrange(Obj *p, int side, double val)	/* record max and min for one direction */
63 
{
64 
	if (!(p->coord&XFLAG) && (side == LEFT || side == RIGHT)) {
65 
		if (val < p->pt.y)
66 
			p->pt.y = val;
67 
		if (val > p->pt1.y)
68 
			p->pt1.y = val;
69 
	} else if (!(p->coord&YFLAG) && (side == TOP || side == BOT)) {
70 
		if (val < p->pt.x)
71 
			p->pt.x = val;
72 
		if (val > p->pt1.x)
73 
			p->pt1.x = val;
74 
	}
75 
}
76 
 
77 
 
78 
Obj *lookup(char *s, int inst)	/* find s in objlist, install if inst */
79 
{
80 
	Obj *p;
81 
	int found = 0;
82 
 
83 
	for (p = objlist; p; p = p->next){
84 
		if (strcmp(s, p->name) == 0) {
85 
			found = 1;
86 
			break;
87 
		}
88 
	}
89 
	if (p == NULL && inst != 0) {
90 
		p = (Obj *) calloc(1, sizeof(Obj));
91 
		if (p == NULL)
92 
			ERROR "out of space in lookup" FATAL;
93 
		p->name = tostring(s);
94 
		p->type = NAME;
95 
		p->pt = ptmax;
96 
		p->pt1 = ptmin;
97 
		p->fval = 0.0;
98 
		p->next = objlist;
99 
		objlist = p;
100 
	}
101 
	dprintf("lookup(%s,%d) = %d\n", s, inst, found);
102 
	return p;
103 
}
104 
 
105 
double getvar(Obj *p)	/* return value of variable */
106 
{
107 
	return p->fval;
108 
}
109 
 
110 
double setvar(Obj *p, double f)	/* set value of variable to f */
111 
{
112 
	if (strcmp(p->name, "pointsize") == 0) {	/* kludge */
113 
		pointsize = f;
114 
		ps_set = 1;
115 
	}
116 
	p->type = VARNAME;
117 
	return p->fval = f;
118 
}
119 
 
120 
Point makepoint(Obj *s, double x, double y)	/* make a Point */
121 
{
122 
	Point p;
123 
 
124 
	dprintf("makepoint: %s, %g,%g\n", s->name, x, y);
125 
	p.obj = s;
126 
	p.x = x;
127 
	p.y = y;
128 
	return p;
129 
}
130 
 
131 
Attr *makefattr(int type, double fval)	/* set double in attribute */
132 
{
133 
	return makeattr(type, fval, (char *) 0, 0, 0);
134 
}
135 
 
136 
Attr *makesattr(char *s)		/* make an Attr cell containing s */
137 
{
138 
	Attr *ap = makeattr(STRING, sizexpr, s, just, sizeop);
139 
	just = sizeop = 0;
140 
	sizexpr = 0.0;
141 
	return ap;
142 
}
143 
 
144 
Attr *makeattr(int type, double fval, char *sval, int just, int op)
145 
{
146 
	Attr *a;
147 
 
148 
	a = (Attr *) malloc(sizeof(Attr));
149 
	if (a == NULL)
150 
		ERROR "out of space in makeattr" FATAL;
151 
	a->type = type;
152 
	a->fval = fval;
153 
	a->sval = sval;
154 
	a->just = just;
155 
	a->op = op;
156 
	a->next = NULL;
157 
	return a;
158 
}
159 
 
160 
Attr *addattr(Attr *a1, Attr *ap)	/* add attr ap to end of list a1 */
161 
{
162 
	Attr *p;
163 
 
164 
	if (a1 == 0)
165 
		return ap;
166 
	if (ap == 0)
167 
		return a1;
168 
	for (p = a1; p->next; p = p->next)
169 
		;
170 
	p->next = ap;
171 
	return a1;
172 
}
173 
 
174 
void freeattr(Attr *ap)	/* free an attribute list */
175 
{
176 
	Attr *p;
177 
 
178 
	while (ap) {
179 
		p = ap->next;	/* save next */
180 
		if (ap->sval)
181 
			free(ap->sval);
182 
		free((char *) ap);
183 
		ap = p;
184 
	}
185 
}
186 
 
187 
char *slprint(Attr *stringlist)	/* print strings from stringlist */
188 
{
189 
	int ntext, n, last_op, last_just;
190 
	double last_fval;
191 
	static char buf[1000];
192 
	Attr *ap;
193 
 
194 
	buf[0] = '\0';
195 
	last_op = last_just = 0;
196 
	last_fval = 0.0;
197 
	for (ntext = 0, ap = stringlist; ap != NULL; ap = ap->next)
198 
		ntext++;
199 
	sprintf(buf, "box invis wid 0 ht %d*textht", ntext);
200 
	n = strlen(buf);
201 
	for (ap = stringlist; ap != NULL; ap = ap->next) {
202 
		if (ap->op == 0) {	/* propagate last value */
203 
			ap->op = last_op;
204 
			ap->fval = last_fval;
205 
		} else {
206 
			last_op = ap->op;
207 
			last_fval = ap->fval;
208 
		}
209 
		sprintf(buf+n, " \"%s\"", ps_set || ap->op ? sizeit(ap) : ap->sval);
210 
		if (ap->just)
211 
			last_just = ap->just;
212 
		if (last_just)
213 
			strcat(buf+n, juststr(last_just));
214 
		n = strlen(buf);
215 
	}
216 
	return buf;	/* watch it:  static */
217 
}
218 
 
219 
char *juststr(int j)	/* convert RJUST, etc., into string */
220 
{
221 
	static char buf[50];
222 
 
223 
	buf[0] = '\0';
224 
	if (j & RJUST)
225 
		strcat(buf, " rjust");
226 
	if (j & LJUST)
227 
		strcat(buf, " ljust");
228 
	if (j & ABOVE)
229 
		strcat(buf, " above");
230 
	if (j & BELOW)
231 
		strcat(buf, " below");
232 
	return buf;	/* watch it:  static */
233 
}
234 
 
235 
char *sprntf(char *s, Attr *ap)	/* sprintf(s, attrlist ap) */
236 
{
237 
	char buf[500];
238 
	int n;
239 
	Attr *p;
240 
 
241 
	for (n = 0, p = ap; p; p = p->next)
242 
		n++;
243 
	switch (n) {
244 
	case 0:
245 
		return s;
246 
	case 1:
247 
		sprintf(buf, s, ap->fval);
248 
		break;
249 
	case 2:
250 
		sprintf(buf, s, ap->fval, ap->next->fval);
251 
		break;
252 
	case 3:
253 
		sprintf(buf, s, ap->fval, ap->next->fval, ap->next->next->fval);
254 
		break;
255 
	case 5:
256 
		ERROR "too many expressions in sprintf" WARNING;
257 
	case 4:
258 
		sprintf(buf, s, ap->fval, ap->next->fval, ap->next->next->fval, ap->next->next->next->fval);
259 
		break;
260 
	}
261 
	free(s);
262 
	return tostring(buf);
263 
}