![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to picassol.l CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / picasso|
Return to picassol.l CVS log | Up to [Research Unix] / researchv10dc / cmd / picasso |
1.1 root 1: %Start A str def sc br thru sh eqn
2: %e 1900
3: %k 150
4: %a 2100
5: %o 1650
6: %p 5300
7: %n 750
8:
9: %{
10: #undef input
11: #undef unput
12: #include <ctype.h>
13: #include <math.h>
14: #include "picasso.h"
15: #include "y.tab.h"
16:
17: extern double atof();
18: extern struct symtab symtab[];
19: extern char *filename, *copythru();
20:
21: #define CADD cbuf[clen++]=yytext[0];\
22: if(clen>=CBUFLEN-1) {yyerror("string too long",cbuf); BEGIN A;}
23: #define CBUFLEN 500
24:
25: char cbuf[CBUFLEN];
26: int c, clen, cflag, delim;
27: int ifsw = 0; /* 1 if if statement in progress */
28: %}
29:
30: A [a-zA-Z_]
31: B [a-zA-Z0-9_]
32: D [0-9]
33: WS [ \t]
34:
35: %%
36: switch (yybgin-yysvec-1) { /* witchcraft */
37: case 0:
38: BEGIN A;
39: break;
40: case sc:
41: BEGIN A;
42: return('}');
43: case br:
44: BEGIN A;
45: return(']');
46: }
47:
48: <A>{WS} ;
49: <A>"\\"\n ;
50: <A>\n { return(ST); }
51: <A>";" { return(ST); }
52: <A>"}" { BEGIN sc; return(ST); }
53: <A>"]" { BEGIN br; return(ST); }
54:
55: <A>^".PS".* { if (curfile == infile) yyerror(".PS found inside .PS/.PE"); }
56: <A>^"."P[EFN].* { if (curfile == infile) {
57: yylval.i = yytext[2];
58: PEseen = 1;
59: return(EOF);
60: }
61: }
62: <A>^".EQ".* { BEGIN eqn; eqn_save(yytext); return(ST); }
63: <eqn>^".EN".* { eqn_save(yytext); eqn_gen(TROFF); BEGIN A; return(ST); }
64: <eqn>^.* { eqn_save(yytext); return(ST); }
65: <eqn>\n ;
66: <A>^".".* { yylval.p = tostring(yytext); return(TROFF); }
67:
68: <A>print return(yylval.i = PRINT);
69: <A>show return(yylval.i = SHOW);
70: <A>box return(yylval.i = BOX);
71: <A>circle return(yylval.i = CIRCLE);
72: <A>arc return(yylval.i = ARC);
73: <A>sector return(yylval.i = SECTOR);
74: <A>ellipse return(yylval.i = ELLIPSE);
75: <A>arrow return(yylval.i = ARROW);
76: <A>spline return(yylval.i = SPLINE);
77: <A>line return(yylval.i = LINE);
78: <A>move return(yylval.i = MOVE);
79: <A>psfile return(yylval.i = PSFILE);
80: <A>(block|"[]") return(yylval.i = BLOCK);
81: <A>text return(yylval.i = TEXTOBJ);
82: <A>object return(yylval.i = OBJECT);
83: <A>reset return(RESET);
84: <A>sprintf return(SPRINTF);
85:
86: <A>rot(ate)? return(yylval.i = ROTATE);
87: <A>trans(late)? return(yylval.i = TRANSLATE);
88: <A>scale return(yylval.i = SCALE);
89: <A>reflect return(yylval.i = REFLECT);
90: <A>transform return(yylval.i = TRANSFORM);
91:
92: <A>same return(SAME);
93: <A>between return(BETWEEN);
94: <A>and return(AND);
95:
96: <A>of ;
97: <A>the ;
98: <A>way ;
99:
100: <A>"."(e|east) { yylval.i = EAST; return(CORNER); }
101: <A>"."(r|right) { yylval.i = EAST; return(CORNER); }
102: <A>"."(w|west) { yylval.i = WEST; return(CORNER); }
103: <A>"."(l|left) { yylval.i = WEST; return(CORNER); }
104: <A>"."(n|north) { yylval.i = NORTH; return(CORNER); }
105: <A>"."(t|top) { yylval.i = NORTH; return(CORNER); }
106: <A>"."(s|south) { yylval.i = SOUTH; return(CORNER); }
107: <A>"."(b|bot|bottom) { yylval.i = SOUTH; return(CORNER); }
108: <A>"."(c|center) { yylval.i = CENTER; return(CORNER); }
109: <A>"."(ne|northeast) { yylval.i = NE; return(CORNER); }
110: <A>"."(se|southeast) { yylval.i = SE; return(CORNER); }
111: <A>"."(nw|northwest) { yylval.i = NW; return(CORNER); }
112: <A>"."(sw|southwest) { yylval.i = SW; return(CORNER); }
113: <A>".end" { yylval.i = END; return(CORNER); }
114: <A>".start" { yylval.i = START; return(CORNER); }
115:
116: <A>".first" { yylval.i = 1; return(DOTNTH); }
117: <A>"."{D}+(th|nd|rd|st) { yylval.i = atoi(yytext+1); return(DOTNTH); }
118:
119: <A>top" "+of { yylval.i = NORTH; return(CORNER); }
120: <A>north" "+of { yylval.i = NORTH; return(CORNER); }
121: <A>bottom" "+of { yylval.i = SOUTH; return(CORNER); }
122: <A>south" "+of { yylval.i = SOUTH; return(CORNER); }
123: <A>left" "+of { yylval.i = WEST; return(CORNER); }
124: <A>west" "+of { yylval.i = WEST; return(CORNER); }
125: <A>northwest" "+of { yylval.i = NW; return(CORNER); }
126: <A>southwest" "+of { yylval.i = SW; return(CORNER); }
127: <A>right" "+of { yylval.i = EAST; return(CORNER); }
128: <A>east" "+of { yylval.i = EAST; return(CORNER); }
129: <A>northeast" "+of { yylval.i = NE; return(CORNER); }
130: <A>southeast" "+of { yylval.i = SE; return(CORNER); }
131: <A>center" "+of { yylval.i = CENTER; return(CORNER); }
132: <A>start" "+of { yylval.i = START; return(CORNER); }
133: <A>end" "+of { yylval.i = END; return(CORNER); }
134:
135: <A>fill(ed)? { yylval.i = PCOLOR; return(COLOR); }
136: <A>edge(d)? { yylval.i = LCOLOR; return(COLOR); }
137: <A>label(ed)? { yylval.i = TCOLOR; return(COLOR); }
138:
139: <A>height|ht { yylval.i = HEIGHT; return(ATTR); }
140: <A>width|wid { yylval.i = WIDTH; return(ATTR); }
141: <A>radius|rad { yylval.i = RADIUS; return(ATTR); }
142: <A>diameter|diam { yylval.i = DIAMETER; return(ATTR); }
143: <A>left { yylval.i = LEFT; return(DIR); }
144: <A>right { yylval.i = RIGHT; return(DIR); }
145: <A>up { yylval.i = UP; return(DIR); }
146: <A>down { yylval.i = DOWN; return(DIR); }
147: <A>cw { yylval.i = CW; return(ATTR); }
148: <A>clockwise { yylval.i = CW; return(ATTR); }
149: <A>ccw { yylval.i = CCW; return(ATTR); }
150: <A>noedge { yylval.i = NOEDGE; return(ATTR); }
151: <A>invis(ible)? { yylval.i = NOEDGE; return(ATTR); }
152: <A>layer { yylval.i = LAYER; return(ATTR); }
153: <A>weight|wt { yylval.i = LWEIGHT; return(ATTR); }
154: <A>dot(ted)? return(yylval.i = DOT);
155: <A>dashpat return(yylval.i = DASHPAT);
156: <A>dash(ed)? return(yylval.i = DASH);
157: <A>chop return(yylval.i = CHOP);
158: <A>size return(yylval.i = SIZE);
159: <A>space return(yylval.i = SPACE);
160: <A>font return(yylval.i = FONT);
161: <A>setrgb return(yylval.i = RGB);
162: <A>setfont return(yylval.i = SETFONT);
163:
164: <A>ljust { yylval.i = LJUST; return TEXTATTR; }
165: <A>rjust { yylval.i = RJUST; return TEXTATTR; }
166: <A>above { yylval.i = ABOVE; return TEXTATTR; }
167: <A>below { yylval.i = BELOW; return TEXTATTR; }
168: <A>center { yylval.i = CENTER; return TEXTATTR; }
169:
170: <A>"<-" { yylval.i = HEAD1; return(HEAD); }
171: <A>"->" { yylval.i = HEAD2; return(HEAD); }
172: <A>"<->" { yylval.i = HEAD12; return(HEAD); }
173:
174: <A>".x" return(yylval.i = DOTX);
175: <A>".y" return(yylval.i = DOTY);
176: <A>"."(ht|height) return(yylval.i = DOTHT);
177: <A>"."(wid|width) return(yylval.i = DOTWID);
178: <A>"."(rad|radius) return(yylval.i = DOTRAD);
179:
180: <A>from return(yylval.i = FROM);
181: <A>to return(yylval.i = TO);
182: <A>touch(ing)? return(yylval.i = LOCUS);
183: <A>at return(yylval.i = AT);
184: <A>about return(yylval.i = AT);
185: <A>by return(yylval.i = BY);
186: <A>with return(yylval.i = WITH);
187: <A>last return(yylval.i = LAST);
188: <A>del(ete)? return(yylval.i = DELETE);
189:
190: <A>abs return(ABS);
191: <A>ln return(LOG);
192: <A>log return(LOG10);
193: <A>exp return(EXP);
194: <A>pow return(POW);
195: <A>sin return(SIN);
196: <A>cos return(COS);
197: <A>atan2 return(ATAN2);
198: <A>sqrt return(SQRT);
199: <A>rand return(RAND);
200: <A>max return(MAX);
201: <A>min return(MIN);
202: <A>int return(INT);
203:
204: <A>"==" return(EQ);
205: <A>">=" return(GE);
206: <A>"<=" return(LE);
207: <A>"!=" return(NEQ);
208: <A>">" return(GT);
209: <A>"<" return(LT);
210: <A>"&&" return(ANDAND);
211: <A>"||" return(OROR);
212: <A>"!" return(NOT);
213:
214: <A>Here return(yylval.i = HERE);
215:
216: <A>for { return(FOR); }
217: <A>^_Endfor\n { endfor(); }
218: <A>do { yylval.p = delimstr("loop body"); return(DOSTR); }
219:
220: <A>dup(licate)? return(DUP);
221: <A>copy|include return(COPY);
222: <A>(thru|through){WS}+ { BEGIN thru; return(THRU); }
223: <thru>{A}{B}*|. { yylval.p = copythru(yytext); BEGIN A; return(DEFNAME); }
224: <A>until return(UNTIL);
225:
226: <A>if { ifsw = 1; return(IF); }
227: <A>then { if (!ifsw) { yylval.i = THEN; return(ATTR); }
228: yylval.p = delimstr("then part"); ifsw = 0;
229: return(THENSTR); }
230: <A>else { yylval.p = delimstr("else part"); return(ELSESTR); }
231:
232: <A>sh{WS}+ { BEGIN sh;
233: if ((delim = input()) == '{') delim = '}';
234: /* no nested {} */
235: shell_init(); }
236: <sh>{A}{B}* { struct symtab *p;
237: if (yytext[0] == delim) {
238: shell_exec();
239: BEGIN A;
240: } else {
241: p = lookup(yytext, 0);
242: if (p != NULL && p->s_type == DEFNAME) {
243: c = input();
244: unput(c);
245: if (c == '(')
246: dodef(p);
247: else
248: pbstr(p->s_val.p);
249: } else
250: shell_text(yytext);
251: }
252: }
253: <sh>.|\n { if (yytext[0] == delim) {
254: shell_exec();
255: BEGIN A;
256: } else
257: shell_text(yytext);
258: }
259:
260: <A>define{WS}+ { BEGIN def; }
261: <def>{A}{B}* { definition(yytext); BEGIN A; }
262: <A>undef(ine)?{WS}+{A}{B}* { undefine(yytext); }
263:
264: <A>first { yylval.i = 1; return(NTH); }
265: <A>{D}+(th|nd|rd|st) { yylval.i = atoi(yytext); return(NTH); }
266: <A>({D}+("."?){D}*|"."{D}+)((e|E)("+"|-)?{D}+)?d {
267: yylval.f = atof(yytext)*M_PI/180.; return(NUMBER); }
268: <A>({D}+("."?){D}*|"."{D}+)((e|E)("+"|-)?{D}+)?i? {
269: yylval.f = atof(yytext); return(NUMBER); }
270:
271: <A>{A}{B}* { struct symtab *p;
272: p = lookup(yytext);
273: if (p != NULL && p->s_type == DEFNAME) {
274: c = input();
275: unput(c);
276: if (c == '(') /* it's name(...) */
277: dodef(p);
278: else /* no argument list */
279: pbstr(p->s_val);
280: } else {
281: yylval.p = tostring(yytext);
282: if (strcmp(yytext,"textsize")==0) return(TEXTVAR);
283: else if (islower(yytext[0])) return(VARNAME);
284: else return(PLACENAME);
285: }
286: }
287:
288: <A>\" { BEGIN str; clen=0; }
289: <str>\" { cbuf[clen]=0;
290: yylval.p = tostring(cbuf);
291: BEGIN A;
292: return(TEXT);
293: }
294: <str>\n { yyerror("newline in string"); BEGIN A; return(ST); }
295: <str>"\\\"" { cbuf[clen++]='"'; }
296: <str>"\\"t { cbuf[clen++]='\t'; }
297: <str>"\\\\" { cbuf[clen++]='\\'; }
298: <str>. { CADD; }
299:
300: <A>#.* ;
301:
302: <A>. return(yylval.i = yytext[0]);
303:
304: %%
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.