initial commit
Showing the changes to sys/src/cmd/plot/plot.c (1 of 14470 files). Show all
Unified · Split
| @@ -0,0 +1,632 @@ | ||
| 1 | +/* | |
| 2 | + * This file is part of the UCB release of Plan 9. It is subject to the license | |
| 3 | + * terms in the LICENSE file found in the top-level directory of this | |
| 4 | + * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No | |
| 5 | + * part of the UCB release of Plan 9, including this file, may be copied, | |
| 6 | + * modified, propagated, or distributed except according to the terms contained | |
| 7 | + * in the LICENSE file. | |
| 8 | + */ | |
| 9 | + | |
| 10 | +#include <u.h> | |
| 11 | +#include <libc.h> | |
| 12 | +#include <bio.h> | |
| 13 | +#include "plot.h" | |
| 14 | +#include <draw.h> | |
| 15 | +#include <event.h> | |
| 16 | + | |
| 17 | +void define(char*); | |
| 18 | +void call(char*); | |
| 19 | +void include(char*); | |
| 20 | +int process(Biobuf*); | |
| 21 | +int server(void); | |
| 22 | + | |
| 23 | +enum{ | |
| 24 | + ARC, | |
| 25 | + BOX, | |
| 26 | + CALL, | |
| 27 | + CFILL, | |
| 28 | + CIRC, | |
| 29 | + CLOSEPL, | |
| 30 | + COLOR, | |
| 31 | + CSPLINE, | |
| 32 | + DEFINE, | |
| 33 | + DISK, | |
| 34 | + DSPLINE, | |
| 35 | + ERASE, | |
| 36 | + FILL, | |
| 37 | + FRAME, | |
| 38 | + FSPLINE, | |
| 39 | + GRADE, | |
| 40 | + IDLE, | |
| 41 | + INCLUDE, | |
| 42 | + LINE, | |
| 43 | + LSPLINE, | |
| 44 | + MOVE, | |
| 45 | + OPENPL, | |
| 46 | + PARABOLA, | |
| 47 | + PEN, | |
| 48 | + PAUSE, | |
| 49 | + POINT, | |
| 50 | + POLY, | |
| 51 | + RANGE, | |
| 52 | + RESTORE, | |
| 53 | + RMOVE, | |
| 54 | + RVEC, | |
| 55 | + SAVE, | |
| 56 | + SBOX, | |
| 57 | + SPLINE, | |
| 58 | + TEXT, | |
| 59 | + VEC, | |
| 60 | + LAST | |
| 61 | +}; | |
| 62 | + | |
| 63 | +struct pcall { | |
| 64 | + char *cc; | |
| 65 | + int numc; | |
| 66 | +} plots[] = { | |
| 67 | + [ARC] "a", 1, | |
| 68 | + [BOX] "bo", 2, | |
| 69 | + [CALL] "ca", 2, | |
| 70 | + [CFILL] "cf", 2, | |
| 71 | + [CIRC] "ci", 2, | |
| 72 | + [CLOSEPL] "cl", 2, | |
| 73 | + [COLOR] "co", 2, | |
| 74 | + [CSPLINE] "cs", 2, | |
| 75 | + [DEFINE] "de", 2, | |
| 76 | + [DISK] "di", 2, | |
| 77 | + [DSPLINE] "ds", 2, | |
| 78 | + [ERASE] "e", 1, | |
| 79 | + [FILL] "fi", 2, | |
| 80 | + [FRAME] "fr", 2, | |
| 81 | + [FSPLINE] "fs", 2, | |
| 82 | + [GRADE] "g", 1, | |
| 83 | + [IDLE] "id", 2, | |
| 84 | + [INCLUDE] "in", 2, | |
| 85 | + [LINE] "li", 2, | |
| 86 | + [LSPLINE] "ls", 2, | |
| 87 | + [MOVE] "m", 1, | |
| 88 | + [OPENPL] "o", 1, | |
| 89 | + [PARABOLA] "par", 3, | |
| 90 | + [PEN] "pe", 2, | |
| 91 | + [PAUSE] "pau", 3, | |
| 92 | + [POINT] "poi", 3, | |
| 93 | + [POLY] "pol", 3, | |
| 94 | + [RANGE] "ra", 2, | |
| 95 | + [RESTORE] "re", 2, | |
| 96 | + [RMOVE] "rm", 2, | |
| 97 | + [RVEC] "rv", 2, | |
| 98 | + [SAVE] "sa", 2, | |
| 99 | + [SBOX] "sb", 2, | |
| 100 | + [SPLINE] "sp", 2, | |
| 101 | + [TEXT] "t", 1, | |
| 102 | + [VEC] "v", 1, | |
| 103 | + [LAST] 0, 0, | |
| 104 | +}; | |
| 105 | + | |
| 106 | +struct pcall *pplots; /* last command read */ | |
| 107 | + | |
| 108 | +#define MAXL 16 | |
| 109 | +struct fcall { | |
| 110 | + char *name; | |
| 111 | + char *stash; | |
| 112 | +} flibr[MAXL]; /* define strings */ | |
| 113 | + | |
| 114 | +struct fcall *fptr = flibr; | |
| 115 | + | |
| 116 | +#define NFSTACK 50 | |
| 117 | +struct fstack{ | |
| 118 | + int peekc; | |
| 119 | + int lineno; | |
| 120 | + char *corebuf; | |
| 121 | + Biobuf *fd; | |
| 122 | + double scale; | |
| 123 | +}fstack[NFSTACK]; /* stack of open input files & defines */ | |
| 124 | +struct fstack *fsp=fstack; | |
| 125 | + | |
| 126 | +#define NARGSTR 8192 | |
| 127 | +char argstr[NARGSTR+1]; /* string arguments */ | |
| 128 | + | |
| 129 | +#define NX 8192 | |
| 130 | +double x[NX]; /* numeric arguments */ | |
| 131 | + | |
| 132 | +#define NPTS 256 | |
| 133 | +int cnt[NPTS]; /* control-polygon vertex counts */ | |
| 134 | +double *pts[NPTS]; /* control-polygon vertex pointers */ | |
| 135 | + | |
| 136 | +void eresized(int new){ | |
| 137 | + if(new && getwindow(display, Refnone) < 0){ | |
| 138 | + fprint(2, "Can't reattach to window: %r\n"); | |
| 139 | + exits("resize"); | |
| 140 | + } | |
| 141 | +} | |
| 142 | +char *items[]={ | |
| 143 | + "exit", | |
| 144 | + 0 | |
| 145 | +}; | |
| 146 | +Menu menu={items}; | |
| 147 | +void | |
| 148 | +main(int arc, char *arv[]){ | |
| 149 | + char *ap; | |
| 150 | + Biobuf *bp; | |
| 151 | + int fd; | |
| 152 | + int i; | |
| 153 | + int dflag; | |
| 154 | + char *oflag; | |
| 155 | + Mouse m; | |
| 156 | + bp = 0; | |
| 157 | + fd = dup(0, -1); /* because openpl will close 0! */ | |
| 158 | + dflag=0; | |
| 159 | + oflag=""; | |
| 160 | + for(i=1;i!=arc;i++) if(arv[i][0]=='-') switch(arv[i][1]){ | |
| 161 | + case 'd': dflag=1; break; | |
| 162 | + case 'o': oflag=arv[i]+2; break; | |
| 163 | + case 's': fd=server(); break; | |
| 164 | + } | |
| 165 | + openpl(oflag); | |
| 166 | + if(dflag) doublebuffer(); | |
| 167 | + for (; arc > 1; arc--, arv++) { | |
| 168 | + if (arv[1][0] == '-') { | |
| 169 | + ap = arv[1]; | |
| 170 | + ap++; | |
| 171 | + switch (*ap) { | |
| 172 | + default: | |
| 173 | + fprint(2, "%s not allowed as argument\n", ap); | |
| 174 | + exits("usage"); | |
| 175 | + case 'T': break; | |
| 176 | + case 'D': break; | |
| 177 | + case 'd': break; | |
| 178 | + case 'o': break; | |
| 179 | + case 'W': break; | |
| 180 | + case 's': break; | |
| 181 | + case 'e': erase(); break; | |
| 182 | + case 'C': closepl(); break; | |
| 183 | + case 'w': ppause(); break; | |
| 184 | + case 'c': color(ap+1); break; | |
| 185 | + case 'f': cfill(ap+1); break; | |
| 186 | + case 'p': pen(ap+1); break; | |
| 187 | + case 'g': grade(atof(ap+1)); break; | |
| 188 | + } | |
| 189 | + } | |
| 190 | + else if ((bp = Bopen(arv[1], OREAD)) == 0) { | |
| 191 | + perror(arv[1]); | |
| 192 | + fprint(2, "Cannot find file %s\n", arv[1]); | |
| 193 | + } | |
| 194 | + else if(process(bp)) Bterm(fsp->fd); | |
| 195 | + else break; | |
| 196 | + } | |
| 197 | + if (bp == 0){ | |
| 198 | + bp = malloc(sizeof *bp); | |
| 199 | + Binit(bp, fd, OREAD); | |
| 200 | + process(bp); | |
| 201 | + } | |
| 202 | + closepl(); | |
| 203 | + flushimage(display, 1); | |
| 204 | + for(;;){ | |
| 205 | + m=emouse(); | |
| 206 | + if(m.buttons&4 && emenuhit(3, &m, &menu)==0) exits(0); | |
| 207 | + } | |
| 208 | +} | |
| 209 | +int isalpha(int c) | |
| 210 | +{ | |
| 211 | + return ('a'<=c && c<='z') || ('A'<=c && c<='Z'); | |
| 212 | +} | |
| 213 | +int isupper(int c) | |
| 214 | +{ | |
| 215 | + return 'A'<=c && c<='Z'; | |
| 216 | +} | |
| 217 | +int isdigit(int c) | |
| 218 | +{ | |
| 219 | + return '0'<=c && c<='9'; | |
| 220 | +} | |
| 221 | +int ispunct(int c) | |
| 222 | +{ | |
| 223 | + return strchr("!\"#$%&'()*+,-./:;<=>?@[\]^_`{|}~", c)!=0; | |
| 224 | +} | |
| 225 | +int isspace(int c) | |
| 226 | +{ | |
| 227 | + return strchr(" \t\n\v\f\r", c)!=0; | |
| 228 | +} | |
| 229 | +int nextc(void){ | |
| 230 | + int c; | |
| 231 | + Rune r; | |
| 232 | + for(;;){ | |
| 233 | + if(fsp->peekc!=Beof){ | |
| 234 | + c=fsp->peekc; | |
| 235 | + fsp->peekc=Beof; | |
| 236 | + return c; | |
| 237 | + } | |
| 238 | + if(fsp->fd) | |
| 239 | + c=Bgetrune(fsp->fd); | |
| 240 | + else if(*fsp->corebuf){ | |
| 241 | + fsp->corebuf+=chartorune(&r, fsp->corebuf); | |
| 242 | + c=r; | |
| 243 | + }else | |
| 244 | + c=Beof; | |
| 245 | + if(c!=Beof || fsp==fstack) break; | |
| 246 | + if(fsp->fd) Bterm(fsp->fd); | |
| 247 | + --fsp; | |
| 248 | + } | |
| 249 | + if(c=='\n') fsp->lineno++; | |
| 250 | + return c; | |
| 251 | +} | |
| 252 | +/* | |
| 253 | + * Read a string into argstr -- ignores leading spaces | |
| 254 | + * and an optional leading quote-mark | |
| 255 | + */ | |
| 256 | +void | |
| 257 | +strarg(void){ | |
| 258 | + int c; | |
| 259 | + Rune r; | |
| 260 | + int quote=0; | |
| 261 | + char *s=argstr; | |
| 262 | + do | |
| 263 | + c=nextc(); | |
| 264 | + while(c==' ' || c=='\t'); | |
| 265 | + if(c=='\'' || c=='"'){ | |
| 266 | + quote=c; | |
| 267 | + c=nextc(); | |
| 268 | + } | |
| 269 | + r = 0; | |
| 270 | + while(c!='\n' && c!=Beof){ | |
| 271 | + r=c; | |
| 272 | + s+=runetochar(s, &r); | |
| 273 | + c=nextc(); | |
| 274 | + } | |
| 275 | + if(quote && s!=argstr && r==quote) --s; | |
| 276 | + *s='\0'; | |
| 277 | +} | |
| 278 | +/* | |
| 279 | + * Read a floating point number into argstr | |
| 280 | + */ | |
| 281 | +numstring(void){ | |
| 282 | + int ndp=0; | |
| 283 | + int ndig=0; | |
| 284 | + char *s=argstr; | |
| 285 | + int c=nextc(); | |
| 286 | + if(c=='+' || c=='-'){ | |
| 287 | + *s++=c; | |
| 288 | + c=nextc(); | |
| 289 | + } | |
| 290 | + while(isdigit(c) || c=='.'){ | |
| 291 | + if(s!=&argstr[NARGSTR]) *s++=c; | |
| 292 | + if(c=='.') ndp++; | |
| 293 | + else ndig++; | |
| 294 | + c=nextc(); | |
| 295 | + } | |
| 296 | + if(ndp>1 || ndig==0){ | |
| 297 | + fsp->peekc=c; | |
| 298 | + return 0; | |
| 299 | + } | |
| 300 | + if(c=='e' || c=='E'){ | |
| 301 | + if(s!=&argstr[NARGSTR]) *s++=c; | |
| 302 | + c=nextc(); | |
| 303 | + if(c=='+' || c=='-'){ | |
| 304 | + if(s!=&argstr[NARGSTR]) *s++=c; | |
| 305 | + c=nextc(); | |
| 306 | + } | |
| 307 | + if(!isdigit(c)){ | |
| 308 | + fsp->peekc=c; | |
| 309 | + return 0; | |
| 310 | + } | |
| 311 | + while(isdigit(c)){ | |
| 312 | + if(s!=&argstr[NARGSTR]) *s++=c; | |
| 313 | + c=nextc(); | |
| 314 | + } | |
| 315 | + } | |
| 316 | + fsp->peekc=c; | |
| 317 | + *s='\0'; | |
| 318 | + return 1; | |
| 319 | +} | |
| 320 | +/* | |
| 321 | + * Read n numeric arguments, storing them in | |
| 322 | + * x[0], ..., x[n-1] | |
| 323 | + */ | |
| 324 | +void | |
| 325 | +numargs(int n){ | |
| 326 | + int i, c; | |
| 327 | + for(i=0;i!=n;i++){ | |
| 328 | + do{ | |
| 329 | + c=nextc(); | |
| 330 | + }while(strchr(" \t\n", c) || c!='.' && c!='+' && c!='-' && ispunct(c)); | |
| 331 | + fsp->peekc=c; | |
| 332 | + if(!numstring()){ | |
| 333 | + fprint(2, "line %d: number expected\n", fsp->lineno); | |
| 334 | + exits("input error"); | |
| 335 | + } | |
| 336 | + x[i]=atof(argstr)*fsp->scale; | |
| 337 | + } | |
| 338 | +} | |
| 339 | +/* | |
| 340 | + * Read a list of lists of control vertices, storing points in x[.], | |
| 341 | + * pointers in pts[.] and counts in cnt[.] | |
| 342 | + */ | |
| 343 | +void | |
| 344 | +polyarg(void){ | |
| 345 | + int nleft, l, r, c; | |
| 346 | + double **ptsp=pts, *xp=x; | |
| 347 | + int *cntp=cnt; | |
| 348 | + do{ | |
| 349 | + c=nextc(); | |
| 350 | + }while(c==' ' || c=='\t'); | |
| 351 | + if(c=='{'){ | |
| 352 | + l='{'; | |
| 353 | + r='}'; | |
| 354 | + } | |
| 355 | + else{ | |
| 356 | + l=r='\n'; | |
| 357 | + fsp->peekc=c; | |
| 358 | + } | |
| 359 | + nleft=1; | |
| 360 | + *cntp=0; | |
| 361 | + *ptsp=xp; | |
| 362 | + for(;;){ | |
| 363 | + c=nextc(); | |
| 364 | + if(c==r){ | |
| 365 | + if(*cntp){ | |
| 366 | + if(*cntp&1){ | |
| 367 | + fprint(2, "line %d: phase error\n", | |
| 368 | + fsp->lineno); | |
| 369 | + exits("bad input"); | |
| 370 | + } | |
| 371 | + *cntp/=2; | |
| 372 | + if(ptsp==&pts[NPTS]){ | |
| 373 | + fprint(2, "line %d: out of polygons\n", | |
| 374 | + fsp->lineno); | |
| 375 | + exits("exceeded limit"); | |
| 376 | + } | |
| 377 | + *++ptsp=xp; | |
| 378 | + *++cntp=0; | |
| 379 | + } | |
| 380 | + if(--nleft==0) return; | |
| 381 | + } | |
| 382 | + else switch(c){ | |
| 383 | + case Beof: return; | |
| 384 | + case ' ': break; | |
| 385 | + case '\t': break; | |
| 386 | + case '\n': break; | |
| 387 | + case '.': case '+': case '-': | |
| 388 | + case '0': case '1': case '2': case '3': case '4': | |
| 389 | + case '5': case '6': case '7': case '8': case '9': | |
| 390 | + fsp->peekc=c; | |
| 391 | + if(!numstring()){ | |
| 392 | + fprint(2, "line %d: expected number\n", fsp->lineno); | |
| 393 | + exits("bad input"); | |
| 394 | + } | |
| 395 | + if(xp==&x[NX]){ | |
| 396 | + fprint(2, "line %d: out of space\n", fsp->lineno); | |
| 397 | + exits("exceeded limit"); | |
| 398 | + } | |
| 399 | + *xp++=atof(argstr); | |
| 400 | + ++*cntp; | |
| 401 | + break; | |
| 402 | + default: | |
| 403 | + if(c==l) nleft++; | |
| 404 | + else if(!ispunct(c)){ | |
| 405 | + fsp->peekc=c; | |
| 406 | + return; | |
| 407 | + } | |
| 408 | + } | |
| 409 | + } | |
| 410 | +} | |
| 411 | + | |
| 412 | +process(Biobuf *fd){ | |
| 413 | + char *s; | |
| 414 | + int c; | |
| 415 | + fsp=fstack; | |
| 416 | + fsp->fd=fd; | |
| 417 | + fsp->corebuf=0; | |
| 418 | + fsp->peekc=Beof; | |
| 419 | + fsp->lineno=1; | |
| 420 | + fsp->scale=1.; | |
| 421 | + for(;;){ | |
| 422 | + do | |
| 423 | + c=nextc(); | |
| 424 | + while(c==' ' || c=='\t'); | |
| 425 | + if(c==':'){ | |
| 426 | + do | |
| 427 | + c=nextc(); | |
| 428 | + while(c!='\n' && c!=Beof); | |
| 429 | + if(c==Beof) break; | |
| 430 | + continue; | |
| 431 | + } | |
| 432 | + while(c=='.'){ | |
| 433 | + c=nextc(); | |
| 434 | + if(isdigit(c)){ | |
| 435 | + if(fsp->fd) Bungetc(fsp->fd); | |
| 436 | + else --fsp->corebuf; | |
| 437 | + c='.'; | |
| 438 | + break; | |
| 439 | + } | |
| 440 | + } | |
| 441 | + if(c==Beof) break; | |
| 442 | + if(c=='\n') continue; | |
| 443 | + if(isalpha(c)){ | |
| 444 | + s=argstr; | |
| 445 | + do{ | |
| 446 | + if(isupper(c)) c=tolower(c); | |
| 447 | + if(s!=&argstr[NARGSTR]) *s++=c; | |
| 448 | + c=nextc(); | |
| 449 | + }while(isalpha(c)); | |
| 450 | + fsp->peekc=c; | |
| 451 | + *s='\0'; | |
| 452 | + for(pplots=plots;pplots->cc;pplots++) | |
| 453 | + if(strncmp(argstr, pplots->cc, pplots->numc)==0) | |
| 454 | + break; | |
| 455 | + if(pplots->cc==0){ | |
| 456 | + fprint(2, "line %d, %s unknown\n", fsp->lineno, | |
| 457 | + argstr); | |
| 458 | + exits("bad command"); | |
| 459 | + } | |
| 460 | + } | |
| 461 | + else{ | |
| 462 | + fsp->peekc=c; | |
| 463 | + } | |
| 464 | + if(!pplots){ | |
| 465 | + fprint(2, "line %d, no command!\n", fsp->lineno); | |
| 466 | + exits("no command"); | |
| 467 | + } | |
| 468 | + switch(pplots-plots){ | |
| 469 | + case ARC: numargs(7); rarc(x[0],x[1],x[2],x[3],x[4],x[5],x[6]); break; | |
| 470 | + case BOX: numargs(4); box(x[0], x[1], x[2], x[3]); break; | |
| 471 | + case CALL: strarg(); call(argstr); pplots=0; break; | |
| 472 | + case CFILL: strarg(); cfill(argstr); pplots=0; break; | |
| 473 | + case CIRC: numargs(3); circ(x[0], x[1], x[2]); break; | |
| 474 | + case CLOSEPL: strarg(); closepl(); pplots=0; break; | |
| 475 | + case COLOR: strarg(); color(argstr); pplots=0; break; | |
| 476 | + case CSPLINE: polyarg(); splin(4, cnt, pts); break; | |
| 477 | + case DEFINE: strarg(); define(argstr); pplots=0; break; | |
| 478 | + case DISK: numargs(3); plotdisc(x[0], x[1], x[2]); break; | |
| 479 | + case DSPLINE: polyarg(); splin(3, cnt, pts); break; | |
| 480 | + case ERASE: strarg(); erase(); pplots=0; break; | |
| 481 | + case FILL: polyarg(); fill(cnt, pts); break; | |
| 482 | + case FRAME: numargs(4); frame(x[0], x[1], x[2], x[3]); break; | |
| 483 | + case FSPLINE: polyarg(); splin(1, cnt, pts); break; | |
| 484 | + case GRADE: numargs(1); grade(x[0]); break; | |
| 485 | + case IDLE: strarg(); idle(); pplots=0; break; | |
| 486 | + case INCLUDE: strarg(); include(argstr); pplots=0; break; | |
| 487 | + case LINE: numargs(4); plotline(x[0], x[1], x[2], x[3]); break; | |
| 488 | + case LSPLINE: polyarg(); splin(2, cnt, pts); break; | |
| 489 | + case MOVE: numargs(2); move(x[0], x[1]); break; | |
| 490 | + case OPENPL: strarg(); openpl(argstr); pplots=0; break; | |
| 491 | + case PARABOLA: numargs(6); parabola(x[0],x[1],x[2],x[3],x[4],x[5]); break; | |
| 492 | + case PAUSE: strarg(); ppause(); pplots=0; break; | |
| 493 | + case PEN: strarg(); pen(argstr); pplots=0; break; | |
| 494 | + case POINT: numargs(2); dpoint(x[0], x[1]); break; | |
| 495 | + case POLY: polyarg(); plotpoly(cnt, pts); break; | |
| 496 | + case RANGE: numargs(4); range(x[0], x[1], x[2], x[3]); break; | |
| 497 | + case RESTORE: strarg(); restore(); pplots=0; break; | |
| 498 | + case RMOVE: numargs(2); rmove(x[0], x[1]); break; | |
| 499 | + case RVEC: numargs(2); rvec(x[0], x[1]); break; | |
| 500 | + case SAVE: strarg(); save(); pplots=0; break; | |
| 501 | + case SBOX: numargs(4); sbox(x[0], x[1], x[2], x[3]); break; | |
| 502 | + case SPLINE: polyarg(); splin(0, cnt, pts); break; | |
| 503 | + case TEXT: strarg(); text(argstr); pplots=0; break; | |
| 504 | + case VEC: numargs(2); vec(x[0], x[1]); break; | |
| 505 | + default: | |
| 506 | + fprint(2, "plot: missing case %ld\n", pplots-plots); | |
| 507 | + exits("internal error"); | |
| 508 | + } | |
| 509 | + } | |
| 510 | + return 1; | |
| 511 | +} | |
| 512 | +char *names = 0; | |
| 513 | +char *enames = 0; | |
| 514 | +char *bstash = 0; | |
| 515 | +char *estash = 0; | |
| 516 | +unsigned size = 1024; | |
| 517 | +char *nstash = 0; | |
| 518 | +void define(char *a){ | |
| 519 | + char *ap; | |
| 520 | + short i, j; | |
| 521 | + int curly = 0; | |
| 522 | + ap = a; | |
| 523 | + while(isalpha(*ap))ap++; | |
| 524 | + if(ap == a){ | |
| 525 | + fprint(2,"no name with define\n"); | |
| 526 | + exits("define"); | |
| 527 | + } | |
| 528 | + i = ap - a; | |
| 529 | + if(names+i+1 > enames){ | |
| 530 | + names = malloc((unsigned)512); | |
| 531 | + enames = names + 512; | |
| 532 | + } | |
| 533 | + fptr->name = names; | |
| 534 | + strncpy(names, a,i); | |
| 535 | + names += i; | |
| 536 | + *names++ = '\0'; | |
| 537 | + if(!bstash){ | |
| 538 | + bstash = nstash = malloc(size); | |
| 539 | + estash = bstash + size; | |
| 540 | + } | |
| 541 | + fptr->stash = nstash; | |
| 542 | + while(*ap != '{') | |
| 543 | + if(*ap == '\n'){ | |
| 544 | + if((ap=Brdline(fsp->fd, '\n'))==0){ | |
| 545 | + fprint(2,"unexpected end of file\n"); | |
| 546 | + exits("eof"); | |
| 547 | + } | |
| 548 | + } | |
| 549 | + else ap++; | |
| 550 | + while((j=Bgetc(fsp->fd))!= Beof){ | |
| 551 | + if(j == '{')curly++; | |
| 552 | + else if(j == '}'){ | |
| 553 | + if(curly == 0)break; | |
| 554 | + else curly--; | |
| 555 | + } | |
| 556 | + *nstash++ = j; | |
| 557 | + if(nstash == estash){ | |
| 558 | + free(bstash); | |
| 559 | + size += 1024; | |
| 560 | + bstash = realloc(bstash,size); | |
| 561 | + estash = bstash+size; | |
| 562 | + } | |
| 563 | + } | |
| 564 | + *nstash++ = '\0'; | |
| 565 | + if(fptr++ >= &flibr[MAXL]){ | |
| 566 | + fprint(2,"Too many objects\n"); | |
| 567 | + exits("too many objects"); | |
| 568 | + } | |
| 569 | +} | |
| 570 | +void call(char *a){ | |
| 571 | + char *ap; | |
| 572 | + struct fcall *f; | |
| 573 | + char sav; | |
| 574 | + double SC; | |
| 575 | + ap = a; | |
| 576 | + while(isalpha(*ap))ap++; | |
| 577 | + sav = *ap; | |
| 578 | + *ap = '\0'; | |
| 579 | + for(f=flibr;f<fptr;f++){ | |
| 580 | + if (!(strcmp(a, f->name))) | |
| 581 | + break; | |
| 582 | + } | |
| 583 | + if(f == fptr){ | |
| 584 | + fprint(2, "object %s not defined\n",a); | |
| 585 | + exits("undefined"); | |
| 586 | + } | |
| 587 | + *ap = sav; | |
| 588 | + while (isspace(*ap) || *ap == ',') | |
| 589 | + ap++; | |
| 590 | + if (*ap != '\0') | |
| 591 | + SC = atof(ap); | |
| 592 | + else SC = 1.; | |
| 593 | + if(++fsp==&fstack[NFSTACK]){ | |
| 594 | + fprint(2, "input stack overflow\n"); | |
| 595 | + exits("blew stack"); | |
| 596 | + } | |
| 597 | + fsp->peekc=Beof; | |
| 598 | + fsp->lineno=1; | |
| 599 | + fsp->corebuf=f->stash; | |
| 600 | + fsp->fd=0; | |
| 601 | + fsp->scale=fsp[-1].scale*SC; | |
| 602 | +} | |
| 603 | +void include(char *a){ | |
| 604 | + Biobuf *fd; | |
| 605 | + fd=Bopen(a, OREAD); | |
| 606 | + if(fd==0){ | |
| 607 | + perror(a); | |
| 608 | + exits("can't include"); | |
| 609 | + } | |
| 610 | + if(++fsp==&fstack[NFSTACK]){ | |
| 611 | + fprint(2, "input stack overflow\n"); | |
| 612 | + exits("blew stack"); | |
| 613 | + } | |
| 614 | + fsp->peekc=Beof; | |
| 615 | + fsp->lineno=1; | |
| 616 | + fsp->corebuf=0; | |
| 617 | + fsp->fd=fd; | |
| 618 | +} | |
| 619 | +/* | |
| 620 | + * Doesn't work. Why? | |
| 621 | + */ | |
| 622 | +int server(void){ | |
| 623 | + int fd, p[2]; | |
| 624 | + char buf[32]; | |
| 625 | + pipe(p); | |
| 626 | + fd = create("/srv/plot", 1, 0666); | |
| 627 | + sprint(buf, "%d", p[1]); | |
| 628 | + write(fd, buf, strlen(buf)); | |
| 629 | + close(fd); | |
| 630 | + close(p[1]); | |
| 631 | + return p[0]; | |
| 632 | +} | |