OOP initial commit with new traces.
[Faustine.git] / interpretor / faust-0.9.47mr3 / compiler / draw / drawschema.cpp
1 /************************************************************************
2 ************************************************************************
3 FAUST compiler
4 Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
5 ---------------------------------------------------------------------
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 ************************************************************************
20 ************************************************************************/
21
22 /**
23 * @file drawschema.cpp
24 * Implement block-diagram schema generation in svg or postscript format.
25 * The result is a folder containing one or more schema files in svg or
26 * ps format. Complex block-diagrams are automatically splitted.
27 */
28
29
30 #include <stdio.h>
31 #include <ctype.h>
32 #include <sys/stat.h>
33 #include <sys/types.h>
34 #include <errno.h>
35 #include <string.h>
36
37 #include <ostream>
38 #include <sstream>
39 #include <set>
40 #include <utility>
41 #include <map>
42 #include <stack>
43 #include <string>
44
45 #include "boxes.hh"
46 #include "ppbox.hh"
47 #include "prim2.hh"
48
49 #include <vector>
50 #include "devLib.h"
51 #include "ppbox.hh"
52 #include "xtended.hh"
53 #include "occurrences.hh"
54 #include "boxcomplexity.h"
55
56 #include "schema.h"
57 #include "drawschema.hh"
58 #include "compatibility.hh"
59 #include "names.hh"
60 #include "description.hh"
61 #include "property.hh"
62
63
64
65 #if 0
66 #define linkcolor "#b3d1dc"
67 #define normalcolor "#ffeaa2"
68 #define uicolor "#F1CFA1"
69 #define slotcolor "#ffffd7"
70 #define numcolor "#ffffff"
71 #endif
72
73 #if 0
74 #define linkcolor "#F57900"
75 #define normalcolor "#4B71A1"
76 #define uicolor "#47945E"
77 #define slotcolor "#EDD400"
78 #define numcolor "#4B71A1"
79 #endif
80
81 #if 0
82 #define linkcolor "#47945E"
83 #define normalcolor "#4B71A1"
84 #define uicolor "#f44800"
85 #define slotcolor "#EDD400"
86 #define numcolor "#f44800"
87 #endif
88
89 #if 0
90 #define linkcolor "#47945E"
91 #define normalcolor "#4B71A1"
92 #define uicolor "#816647"
93 #define slotcolor "#EDD400"
94 #define numcolor "#f44800"
95 #endif
96
97 #if 0
98 #define linkcolor "#003366"
99 #define normalcolor "#4B71A1"
100 #define uicolor "#816647"
101 #define slotcolor "#EDD400"
102 #define numcolor "#f44800"
103 #endif
104
105 #if 0
106 #define linkcolor "#003366"
107 #define normalcolor "#4B71A1"
108 #define uicolor "#477881"
109 #define slotcolor "#816647"
110 #define numcolor "#f44800"
111 #endif
112
113
114 #if 1
115 #define linkcolor "#003366"
116 #define normalcolor "#4B71A1"
117 #define uicolor "#477881"
118 #define slotcolor "#47945E"
119 #define numcolor "#f44800"
120 #define invcolor "#ffffff"
121 #endif
122
123 using namespace std;
124
125 // external parameters
126 extern int gFoldThreshold; // max diagram complexity before folding
127
128
129 // internal state during drawing
130 static Occurrences* gOccurrences;
131 static bool sFoldingFlag; // true with complex block-diagrams
132 static stack<Tree> gPendingExp; // Expressions that need to be drawn
133 static set<Tree> gDrawnExp; // Expressions drawn or scheduled so far
134 static const char* gDevSuffix; // .svg or .ps used to choose output device
135 static char gCurrentDir[512]; // room to save current directory name
136 static string gSchemaFileName; // name of schema file beeing generated
137 static map<Tree,string> gBackLink; // link to enclosing file for sub schema
138
139 // prototypes of internal functions
140 static void writeSchemaFile(Tree bd);
141 static schema* generateDiagramSchema (Tree bd);
142 static schema* generateInsideSchema(Tree t);
143 static void scheduleDrawing(Tree t);
144 static bool pendingDrawing(Tree& t);
145 static schema* generateAbstractionSchema(schema* x, Tree t);
146 static schema* generateOutputSlotSchema(Tree a);
147 static schema* generateInputSlotSchema(Tree a);
148 static schema* generateBargraphSchema(Tree t);
149 static schema* generateUserInterfaceSchema(Tree t);
150 static char* legalFileName(Tree t, int n, char* dst);
151 static int cholddir ();
152 static int mkchdir(const char* dirname);
153
154
155
156
157 /**
158 *The entry point to generate from a block diagram as a set of
159 *svg files stored in the directory "<projname>-svg/" or
160 *"<projname>-ps/" depending of <dev>.
161 */
162 void drawSchema(Tree bd, const char* projname, const char* dev)
163 {
164 gDevSuffix = dev;
165 sFoldingFlag = boxComplexity(bd) > gFoldThreshold;
166
167 mkchdir(projname); // create a directory to store files
168
169 scheduleDrawing(bd); // schedule the initial drawing
170
171 Tree t; while (pendingDrawing(t)) {
172 writeSchemaFile(t); // generate all the pending drawing
173 }
174
175 cholddir(); // return to current directory
176 }
177
178
179 /************************************************************************
180 ************************************************************************
181 IMPLEMENTATION
182 ************************************************************************
183 ************************************************************************/
184
185
186 //------------------- to schedule and retreive drawing ------------------
187
188 /**
189 * Schedule a makeBlockSchema diagram to be drawn.
190 */
191 static void scheduleDrawing(Tree t)
192 {
193 if (gDrawnExp.find(t) == gDrawnExp.end()) {
194 gDrawnExp.insert(t);
195 gBackLink.insert(make_pair(t,gSchemaFileName)); // remember the enclosing filename
196 gPendingExp.push(t);
197 }
198 }
199
200 /**
201 * Retrieve next block diagram that must be drawn
202 */
203 static bool pendingDrawing(Tree& t)
204 {
205 if (gPendingExp.empty()) return false;
206 t = gPendingExp.top();
207 gPendingExp.pop();
208 return true;
209 }
210
211
212
213 //------------------------ dealing with files -------------------------
214
215 /**
216 * Write a top level diagram. A top level diagram
217 * is decorated with its definition name property
218 * and is drawn in an individual file
219 */
220 static void writeSchemaFile(Tree bd)
221 {
222 Tree id;
223 schema* ts;
224
225 char temp[1024];
226
227 gOccurrences = new Occurrences(bd);
228
229 bool hasname = getDefNameProperty(bd, id);
230
231 //assert(hasname);
232 if (!hasname) {
233 // create an arbitrary name
234 id = tree(Node(unique("diagram_")));
235 }
236
237 // generate legal file name for the schema
238 stringstream s1; s1 << legalFileName(bd, 1024, temp) << "." << gDevSuffix;
239 gSchemaFileName = s1.str();
240
241 // generate the label of the schema
242 stringstream s2; s2 << tree2str(id);
243 string link = gBackLink[bd];
244 ts = makeTopSchema(generateInsideSchema(bd), 20, s2.str(), link);
245 // draw to the device defined by gDevSuffix
246 if (strcmp(gDevSuffix, "svg") == 0) {
247 SVGDev dev(s1.str().c_str(), ts->width(), ts->height());
248 ts->place(0,0, kLeftRight);
249 ts->draw(dev);
250 { collector c; ts->collectTraits(c); c.draw(dev); }
251 } else {
252 PSDev dev(s1.str().c_str(), ts->width(), ts->height());
253 ts->place(0,0, kLeftRight);
254 ts->draw(dev);
255 {
256 collector c;
257 ts->collectTraits(c);
258 c.draw(dev);
259 }
260 }
261 }
262
263
264
265 /**
266 * Create a new directory in the current one to store the diagrams.
267 * The current directory is saved to be later restaured.
268 */
269 static int mkchdir(const char* dirname)
270 {
271 //cerr << "mkchdir of " << dirname << endl;
272 if (getcwd(gCurrentDir, 512) != 0) {
273 int status = mkdir(dirname, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
274 if (status == 0 || errno == EEXIST) {
275 if (chdir(dirname) == 0) {
276 return 0;
277 }
278 }
279 }
280 perror("mkchdir");
281 exit(errno);
282 //return errno;
283 }
284
285
286 /**
287 *Switch back to the previously stored current directory
288 */
289 static int cholddir ()
290 {
291 if (chdir(gCurrentDir) == 0) {
292 return 0;
293 } else {
294 perror("cholddir");
295 exit(errno);
296 }
297 }
298
299
300 /**
301 * Transform the definition name property of tree <t> into a
302 * legal file name. The resulting file name is stored in
303 * <dst> a table of at least <n> chars. Returns the <dst> pointer
304 * for convenience.
305 */
306 static char* legalFileName(Tree t, int n, char* dst)
307 {
308 Tree id;
309 int i=0;
310 if (getDefNameProperty(t, id)) {
311 const char* src = tree2str(id);
312 for (i=0; isalnum(src[i]) && i<16; i++) {
313 dst[i] = src[i];
314 }
315 }
316 dst[i] = 0;
317 if (strcmp(dst, "process") != 0) {
318 // if it is not process add the hex address to make the name unique
319 snprintf(&dst[i], n-i, "-%p", t);
320 }
321 return dst;
322 }
323
324
325
326 //------------------------ generating the schema -------------------------
327
328
329 /**
330 * isInverter(t) returns true if t == '*(-1)'. This test is used
331 * to simplify diagram by using a special symbol for inverters.
332 */
333 Tree gInverter[6];
334
335 static bool isInverter(Tree t)
336 {
337 // init gInverted table. For some reason doesn't work if done outside
338 if (gInverter[0] == 0) {
339 gInverter[0] = boxSeq(boxPar(boxWire(), boxInt(-1)),boxPrim2(sigMul));
340 gInverter[1] = boxSeq(boxPar(boxInt(-1), boxWire()),boxPrim2(sigMul));
341 gInverter[2] = boxSeq(boxPar(boxWire(), boxReal(-1.0)),boxPrim2(sigMul));
342 gInverter[3] = boxSeq(boxPar(boxReal(-1.0), boxWire()),boxPrim2(sigMul));
343 gInverter[4] = boxSeq(boxPar(boxInt(0), boxWire()),boxPrim2(sigSub));
344 gInverter[5] = boxSeq(boxPar(boxReal(0.0), boxWire()),boxPrim2(sigSub));
345 };
346
347 //cerr << "isInverter " << t << '$' << boxpp(t) << endl;
348 for (int i=0; i<6; i++) {
349 if (t == gInverter[i]) return true;
350 }
351 return false;
352 }
353
354
355 /**
356 * Compute the Pure Routing property, that is expressions
357 * only made of cut, wires and slots. No labels will be
358 * dispayed for pure routing expressions.
359 */
360 property<bool> gPureRoutingProperty;
361
362 static bool isPureRouting(Tree t)
363 {
364 bool r;
365 int ID;
366 Tree x,y;
367
368 if (gPureRoutingProperty.get(t,r)) {
369 return r;
370 } else if ( isBoxCut(t)
371 || isBoxWire(t)
372 || isInverter(t)
373 || isBoxSlot(t, &ID)
374 || (isBoxPar(t,x,y) && isPureRouting(x) && isPureRouting(y))
375 || (isBoxSeq(t,x,y) && isPureRouting(x) && isPureRouting(y))
376 || (isBoxSplit(t,x,y) && isPureRouting(x) && isPureRouting(y))
377 || (isBoxMerge(t,x,y) && isPureRouting(x) && isPureRouting(y))
378 ) {
379 gPureRoutingProperty.set(t,true);
380 return true;
381 } else {
382 gPureRoutingProperty.set(t,false);
383 return false;
384 }
385 }
386
387
388 /**
389 * Generate an appropriate schema according to
390 * the type of block diagram. When folding is requiered,
391 * instead of going down block-diagrams with a name,
392 * schedule them for an individual file.
393 */
394 static schema* generateDiagramSchema(Tree t)
395 {
396 Tree id;
397 int ins, outs;
398
399 //cerr << t << " generateDiagramSchema " << boxpp(t)<< endl;
400
401 if (getDefNameProperty(t, id)) {
402 stringstream s; s << tree2str(id);
403 //cerr << t << "\tNAMED : " << s.str() << endl;
404 }
405
406 if ( sFoldingFlag && /*(gOccurrences->getCount(t) > 0) &&*/
407 (boxComplexity(t) > 2) && getDefNameProperty(t, id)) {
408 char temp[1024];
409 getBoxType(t, &ins, &outs);
410 stringstream s, l;
411 s << tree2str(id);
412 l << legalFileName(t,1024,temp) << "." << gDevSuffix;
413 scheduleDrawing(t);
414 return makeBlockSchema(ins, outs, s.str(), linkcolor, l.str());
415
416 } else if (getDefNameProperty(t, id) && ! isPureRouting(t)) {
417 // named case : not a slot, with a name
418 // draw a line around the object with its name
419 stringstream s; s << tree2str(id);
420 return makeDecorateSchema(generateInsideSchema(t), 10, s.str());
421
422 } else {
423 // normal case
424 return generateInsideSchema(t);
425 }
426 }
427
428
429
430 /**
431 * Generate the inside schema of a block diagram
432 * according to its type
433 */
434 static schema* generateInsideSchema(Tree t)
435 {
436 Tree a, b, ff, l, type,name,file;
437 int i;
438 double r;
439 prim0 p0;
440 prim1 p1;
441 prim2 p2;
442 prim3 p3;
443 prim4 p4;
444 prim5 p5;
445
446
447 xtended* xt = (xtended*)getUserData(t);
448
449 if (xt) { return makeBlockSchema(xt->arity(), 1, xt->name(), normalcolor, ""); }
450
451 else if (isInverter(t)) { return makeInverterSchema(invcolor); }
452
453 else if (isBoxInt(t, &i)) { stringstream s; s << i; return makeBlockSchema(0, 1, s.str(), numcolor, "" ); }
454 else if (isBoxReal(t, &r)) { stringstream s; s << r; return makeBlockSchema(0, 1, s.str(), numcolor, "" ); }
455 else if (isBoxWire(t)) { return makeCableSchema(); }
456 else if (isBoxCut(t)) { return makeCutSchema(); }
457
458 else if (isBoxPrim0(t, &p0)) { return makeBlockSchema(0, 1, prim0name(p0), normalcolor, ""); }
459 else if (isBoxPrim1(t, &p1)) { return makeBlockSchema(1, 1, prim1name(p1), normalcolor, ""); }
460 else if (isBoxPrim2(t, &p2)) { return makeBlockSchema(2, 1, prim2name(p2), normalcolor, ""); }
461 else if (isBoxPrim3(t, &p3)) { return makeBlockSchema(3, 1, prim3name(p3), normalcolor, ""); }
462 else if (isBoxPrim4(t, &p4)) { return makeBlockSchema(4, 1, prim4name(p4), normalcolor, ""); }
463 else if (isBoxPrim5(t, &p5)) { return makeBlockSchema(5, 1, prim5name(p5), normalcolor, ""); }
464
465 else if (isBoxFFun(t, ff)) { return makeBlockSchema(ffarity(ff), 1, ffname(ff), normalcolor, ""); }
466 else if (isBoxFConst(t, type,name,file)) { return makeBlockSchema(0, 1, tree2str(name), normalcolor, ""); }
467 else if (isBoxFVar (t, type, name,file)) { return makeBlockSchema(0, 1, tree2str(name), normalcolor, ""); }
468
469 else if (isBoxButton(t)) { return generateUserInterfaceSchema(t); }
470 else if (isBoxCheckbox(t)) { return generateUserInterfaceSchema(t); }
471 else if (isBoxVSlider(t)) { return generateUserInterfaceSchema(t); }
472 else if (isBoxHSlider(t)) { return generateUserInterfaceSchema(t); }
473 else if (isBoxNumEntry(t)) { return generateUserInterfaceSchema(t); }
474 else if (isBoxVBargraph(t)) { return generateBargraphSchema(t); }
475 else if (isBoxHBargraph(t)) { return generateBargraphSchema(t); }
476
477 // don't draw group rectangle when labels are empty (ie "")
478 else if (isBoxVGroup(t,l,a)) { stringstream s; s << "vgroup(" << extractName(l) << ")";
479 schema* r = generateDiagramSchema(a);
480 return makeDecorateSchema(r, 10, s.str()); }
481 else if (isBoxHGroup(t,l,a)) { stringstream s; s << "hgroup(" << extractName(l) << ")";
482 schema* r = generateDiagramSchema(a);
483 return makeDecorateSchema(r, 10, s.str()); }
484 else if (isBoxTGroup(t,l,a)) { stringstream s; s << "tgroup(" << extractName(l) << ")";
485 schema* r = generateDiagramSchema(a);
486 return makeDecorateSchema(r, 10, s.str()); }
487
488 else if (isBoxSeq(t, a, b)) { return makeSeqSchema(generateDiagramSchema(a), generateDiagramSchema(b)); }
489 else if (isBoxPar(t, a, b)) { return makeParSchema(generateDiagramSchema(a), generateDiagramSchema(b)); }
490 else if (isBoxSplit(t, a, b)) { return makeSplitSchema(generateDiagramSchema(a), generateDiagramSchema(b)); }
491 else if (isBoxMerge(t, a, b)) { return makeMergeSchema(generateDiagramSchema(a), generateDiagramSchema(b)); }
492 else if (isBoxRec(t, a, b)) { return makeRecSchema(generateDiagramSchema(a), generateDiagramSchema(b)); }
493
494 else if (isBoxSlot(t, &i)) { return generateOutputSlotSchema(t); }
495 else if (isBoxSymbolic(t,a,b)) {
496 Tree id;
497 if (getDefNameProperty(t, id)) {
498 return generateAbstractionSchema(generateInputSlotSchema(a), b);
499 } else {
500 return makeDecorateSchema(generateAbstractionSchema(generateInputSlotSchema(a), b), 10, "Abstraction");
501 }
502 }
503
504 else {
505
506 fprintf(stderr, "Internal Error, box expression not recognized : "); print(t, stderr); fprintf(stderr, "\n");
507 exit(1);
508
509 }
510 }
511
512 /**
513 * Convert User interface element into a textual representation
514 */
515 static void UserInterfaceDescription(Tree box, string& d)
516 {
517 Tree t1, label, cur, min, max, step;
518 stringstream fout;
519 // user interface
520 if (isBoxButton(box, label)) fout << "button(" << extractName(label) << ')';
521 else if (isBoxCheckbox(box, label)) fout << "checkbox(" << extractName(label) << ')';
522 else if (isBoxVSlider(box, label, cur, min, max, step)) {
523 fout << "vslider("
524 << extractName(label) << ", "
525 << boxpp(cur) << ", "
526 << boxpp(min) << ", "
527 << boxpp(max) << ", "
528 << boxpp(step)<< ')';
529 }
530 else if (isBoxHSlider(box, label, cur, min, max, step)) {
531 fout << "hslider("
532 << extractName(label) << ", "
533 << boxpp(cur) << ", "
534 << boxpp(min) << ", "
535 << boxpp(max) << ", "
536 << boxpp(step)<< ')';
537 }
538 else if (isBoxVGroup(box, label, t1)) {
539 fout << "vgroup(" << extractName(label) << ", " << boxpp(t1, 0) << ')';
540 }
541 else if (isBoxHGroup(box, label, t1)) {
542 fout << "hgroup(" << extractName(label) << ", " << boxpp(t1, 0) << ')';
543 }
544 else if (isBoxTGroup(box, label, t1)) {
545 fout << "tgroup(" << extractName(label) << ", " << boxpp(t1, 0) << ')';
546 }
547 else if (isBoxHBargraph(box, label, min, max)) {
548 fout << "hbargraph("
549 << extractName(label) << ", "
550 << boxpp(min) << ", "
551 << boxpp(max) << ')';
552 }
553 else if (isBoxVBargraph(box, label, min, max)) {
554 fout << "vbargraph("
555 << extractName(label) << ", "
556 << boxpp(min) << ", "
557 << boxpp(max) << ')';
558 }
559 else if (isBoxNumEntry(box, label, cur, min, max, step)) {
560 fout << "nentry("
561 << extractName(label) << ", "
562 << boxpp(cur) << ", "
563 << boxpp(min) << ", "
564 << boxpp(max) << ", "
565 << boxpp(step)<< ')';
566 }
567 else {
568 cerr << "INTERNAL ERROR : unknow user interface element " << endl;
569 exit(0);
570 }
571 d = fout.str();
572 }
573
574
575 /**
576 * Generate a 0->1 block schema for a user interface element
577 */
578 static schema* generateUserInterfaceSchema(Tree t)
579 {
580 string s; UserInterfaceDescription(t,s);
581 return makeBlockSchema(0, 1, s, uicolor, "");
582 }
583
584
585 /**
586 * Generate a 1->1 block schema for a user interface bargraph
587 */
588 static schema* generateBargraphSchema(Tree t)
589 {
590 string s; UserInterfaceDescription(t,s);
591 return makeBlockSchema(1, 1, s, uicolor, "");
592 }
593
594
595
596 /**
597 * Generate a 1->0 block schema for an input slot
598 */
599 static schema* generateInputSlotSchema(Tree a)
600 {
601 Tree id; assert(getDefNameProperty(a, id));
602 stringstream s; s << tree2str(id);
603 return makeBlockSchema(1, 0, s.str(), slotcolor, "");
604 }
605
606
607
608 /**
609 * Generate a 0->1 block schema for an output slot
610 */
611 static schema* generateOutputSlotSchema(Tree a)
612 {
613 Tree id; assert(getDefNameProperty(a, id));
614 stringstream s; s << tree2str(id);
615 return makeBlockSchema(0, 1, s.str(), slotcolor, "");
616 }
617
618
619
620 /**
621 * Generate an abstraction schema by placing in sequence
622 * the input slots and the body
623 */
624 static schema* generateAbstractionSchema(schema* x, Tree t)
625 {
626 Tree a,b;
627
628 while (isBoxSymbolic(t,a,b)) {
629 x = makeParSchema(x, generateInputSlotSchema(a));
630 t = b;
631 }
632 return makeSeqSchema(x, generateDiagramSchema(t));
633 }
634