+++ /dev/null
-/************************************************************************
- ************************************************************************
- FAUST compiler
- Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
- ---------------------------------------------------------------------
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- ************************************************************************
- ************************************************************************/
-
- /**
- * @file drawschema.cpp
- * Implement block-diagram schema generation in svg or postscript format.
- * The result is a folder containing one or more schema files in svg or
- * ps format. Complex block-diagrams are automatically splitted.
- */
-
-
-#include <stdio.h>
-#include <ctype.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <errno.h>
-#include <string.h>
-
-#include <ostream>
-#include <sstream>
-#include <set>
-#include <utility>
-#include <map>
-#include <stack>
-#include <string>
-
-#include "boxes.hh"
-#include "ppbox.hh"
-#include "prim2.hh"
-
-#include <vector>
-#include "devLib.h"
-#include "ppbox.hh"
-#include "xtended.hh"
-#include "occurrences.hh"
-#include "boxcomplexity.h"
-
-#include "schema.h"
-#include "drawschema.hh"
-#include "compatibility.hh"
-#include "names.hh"
-#include "description.hh"
-#include "property.hh"
-
-
-
-#if 0
-#define linkcolor "#b3d1dc"
-#define normalcolor "#ffeaa2"
-#define uicolor "#F1CFA1"
-#define slotcolor "#ffffd7"
-#define numcolor "#ffffff"
-#endif
-
-#if 0
-#define linkcolor "#F57900"
-#define normalcolor "#4B71A1"
-#define uicolor "#47945E"
-#define slotcolor "#EDD400"
-#define numcolor "#4B71A1"
-#endif
-
-#if 0
-#define linkcolor "#47945E"
-#define normalcolor "#4B71A1"
-#define uicolor "#f44800"
-#define slotcolor "#EDD400"
-#define numcolor "#f44800"
-#endif
-
-#if 0
-#define linkcolor "#47945E"
-#define normalcolor "#4B71A1"
-#define uicolor "#816647"
-#define slotcolor "#EDD400"
-#define numcolor "#f44800"
-#endif
-
-#if 0
-#define linkcolor "#003366"
-#define normalcolor "#4B71A1"
-#define uicolor "#816647"
-#define slotcolor "#EDD400"
-#define numcolor "#f44800"
-#endif
-
-#if 0
-#define linkcolor "#003366"
-#define normalcolor "#4B71A1"
-#define uicolor "#477881"
-#define slotcolor "#816647"
-#define numcolor "#f44800"
-#endif
-
-
-#if 1
-#define linkcolor "#003366"
-#define normalcolor "#4B71A1"
-#define uicolor "#477881"
-#define slotcolor "#47945E"
-#define numcolor "#f44800"
-#define invcolor "#ffffff"
-#endif
-
-using namespace std;
-
-// external parameters
-extern int gFoldThreshold; // max diagram complexity before folding
-
-
-// internal state during drawing
-static Occurrences* gOccurrences;
-static bool sFoldingFlag; // true with complex block-diagrams
-static stack<Tree> gPendingExp; // Expressions that need to be drawn
-static set<Tree> gDrawnExp; // Expressions drawn or scheduled so far
-static const char* gDevSuffix; // .svg or .ps used to choose output device
-static char gCurrentDir[512]; // room to save current directory name
-static string gSchemaFileName; // name of schema file beeing generated
-static map<Tree,string> gBackLink; // link to enclosing file for sub schema
-
-// prototypes of internal functions
-static void writeSchemaFile(Tree bd);
-static schema* generateDiagramSchema (Tree bd);
-static schema* generateInsideSchema(Tree t);
-static void scheduleDrawing(Tree t);
-static bool pendingDrawing(Tree& t);
-static schema* generateAbstractionSchema(schema* x, Tree t);
-static schema* generateOutputSlotSchema(Tree a);
-static schema* generateInputSlotSchema(Tree a);
-static schema* generateBargraphSchema(Tree t);
-static schema* generateUserInterfaceSchema(Tree t);
-static char* legalFileName(Tree t, int n, char* dst);
-static int cholddir ();
-static int mkchdir(const char* dirname);
-
-
-
-
-/**
- *The entry point to generate from a block diagram as a set of
- *svg files stored in the directory "<projname>-svg/" or
- *"<projname>-ps/" depending of <dev>.
- */
-void drawSchema(Tree bd, const char* projname, const char* dev)
-{
- gDevSuffix = dev;
- sFoldingFlag = boxComplexity(bd) > gFoldThreshold;
-
- mkchdir(projname); // create a directory to store files
-
- scheduleDrawing(bd); // schedule the initial drawing
-
- Tree t; while (pendingDrawing(t)) {
- writeSchemaFile(t); // generate all the pending drawing
- }
-
- cholddir(); // return to current directory
-}
-
-
-/************************************************************************
- ************************************************************************
- IMPLEMENTATION
- ************************************************************************
- ************************************************************************/
-
-
-//------------------- to schedule and retreive drawing ------------------
-
-/**
- * Schedule a makeBlockSchema diagram to be drawn.
- */
-static void scheduleDrawing(Tree t)
-{
- if (gDrawnExp.find(t) == gDrawnExp.end()) {
- gDrawnExp.insert(t);
- gBackLink.insert(make_pair(t,gSchemaFileName)); // remember the enclosing filename
- gPendingExp.push(t);
- }
-}
-
-/**
- * Retrieve next block diagram that must be drawn
- */
-static bool pendingDrawing(Tree& t)
-{
- if (gPendingExp.empty()) return false;
- t = gPendingExp.top();
- gPendingExp.pop();
- return true;
-}
-
-
-
-//------------------------ dealing with files -------------------------
-
-/**
- * Write a top level diagram. A top level diagram
- * is decorated with its definition name property
- * and is drawn in an individual file
- */
-static void writeSchemaFile(Tree bd)
-{
- Tree id;
- schema* ts;
-
- char temp[1024];
-
- gOccurrences = new Occurrences(bd);
-
- bool hasname = getDefNameProperty(bd, id);
-
- //assert(hasname);
- if (!hasname) {
- // create an arbitrary name
- id = tree(Node(unique("diagram_")));
- }
-
- // generate legal file name for the schema
- stringstream s1; s1 << legalFileName(bd, 1024, temp) << "." << gDevSuffix;
- gSchemaFileName = s1.str();
-
- // generate the label of the schema
- stringstream s2; s2 << tree2str(id);
- string link = gBackLink[bd];
- ts = makeTopSchema(generateInsideSchema(bd), 20, s2.str(), link);
- // draw to the device defined by gDevSuffix
- if (strcmp(gDevSuffix, "svg") == 0) {
- SVGDev dev(s1.str().c_str(), ts->width(), ts->height());
- ts->place(0,0, kLeftRight);
- ts->draw(dev);
- { collector c; ts->collectTraits(c); c.draw(dev); }
- } else {
- PSDev dev(s1.str().c_str(), ts->width(), ts->height());
- ts->place(0,0, kLeftRight);
- ts->draw(dev);
- {
- collector c;
- ts->collectTraits(c);
- c.draw(dev);
- }
- }
-}
-
-
-
-/**
- * Create a new directory in the current one to store the diagrams.
- * The current directory is saved to be later restaured.
- */
-static int mkchdir(const char* dirname)
-{
- //cerr << "mkchdir of " << dirname << endl;
- if (getcwd(gCurrentDir, 512) != 0) {
- int status = mkdir(dirname, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
- if (status == 0 || errno == EEXIST) {
- if (chdir(dirname) == 0) {
- return 0;
- }
- }
- }
- perror("mkchdir");
- exit(errno);
- //return errno;
-}
-
-
-/**
- *Switch back to the previously stored current directory
- */
-static int cholddir ()
-{
- if (chdir(gCurrentDir) == 0) {
- return 0;
- } else {
- perror("cholddir");
- exit(errno);
- }
-}
-
-
-/**
- * Transform the definition name property of tree <t> into a
- * legal file name. The resulting file name is stored in
- * <dst> a table of at least <n> chars. Returns the <dst> pointer
- * for convenience.
- */
-static char* legalFileName(Tree t, int n, char* dst)
-{
- Tree id;
- int i=0;
- if (getDefNameProperty(t, id)) {
- const char* src = tree2str(id);
- for (i=0; isalnum(src[i]) && i<16; i++) {
- dst[i] = src[i];
- }
- }
- dst[i] = 0;
- if (strcmp(dst, "process") != 0) {
- // if it is not process add the hex address to make the name unique
- snprintf(&dst[i], n-i, "-%p", t);
- }
- return dst;
-}
-
-
-
-//------------------------ generating the schema -------------------------
-
-
-/**
- * isInverter(t) returns true if t == '*(-1)'. This test is used
- * to simplify diagram by using a special symbol for inverters.
- */
-Tree gInverter[6];
-
-static bool isInverter(Tree t)
-{
- // init gInverted table. For some reason doesn't work if done outside
- if (gInverter[0] == 0) {
- gInverter[0] = boxSeq(boxPar(boxWire(), boxInt(-1)),boxPrim2(sigMul));
- gInverter[1] = boxSeq(boxPar(boxInt(-1), boxWire()),boxPrim2(sigMul));
- gInverter[2] = boxSeq(boxPar(boxWire(), boxReal(-1.0)),boxPrim2(sigMul));
- gInverter[3] = boxSeq(boxPar(boxReal(-1.0), boxWire()),boxPrim2(sigMul));
- gInverter[4] = boxSeq(boxPar(boxInt(0), boxWire()),boxPrim2(sigSub));
- gInverter[5] = boxSeq(boxPar(boxReal(0.0), boxWire()),boxPrim2(sigSub));
- };
-
- //cerr << "isInverter " << t << '$' << boxpp(t) << endl;
- for (int i=0; i<6; i++) {
- if (t == gInverter[i]) return true;
- }
- return false;
-}
-
-
-/**
- * Compute the Pure Routing property, that is expressions
- * only made of cut, wires and slots. No labels will be
- * dispayed for pure routing expressions.
- */
-property<bool> gPureRoutingProperty;
-
-static bool isPureRouting(Tree t)
-{
- bool r;
- int ID;
- Tree x,y;
-
- if (gPureRoutingProperty.get(t,r)) {
- return r;
- } else if ( isBoxCut(t)
- || isBoxWire(t)
- || isInverter(t)
- || isBoxSlot(t, &ID)
- || (isBoxPar(t,x,y) && isPureRouting(x) && isPureRouting(y))
- || (isBoxSeq(t,x,y) && isPureRouting(x) && isPureRouting(y))
- || (isBoxSplit(t,x,y) && isPureRouting(x) && isPureRouting(y))
- || (isBoxMerge(t,x,y) && isPureRouting(x) && isPureRouting(y))
- ) {
- gPureRoutingProperty.set(t,true);
- return true;
- } else {
- gPureRoutingProperty.set(t,false);
- return false;
- }
-}
-
-
-/**
- * Generate an appropriate schema according to
- * the type of block diagram. When folding is requiered,
- * instead of going down block-diagrams with a name,
- * schedule them for an individual file.
- */
-static schema* generateDiagramSchema(Tree t)
-{
- Tree id;
- int ins, outs;
-
- //cerr << t << " generateDiagramSchema " << boxpp(t)<< endl;
-
- if (getDefNameProperty(t, id)) {
- stringstream s; s << tree2str(id);
- //cerr << t << "\tNAMED : " << s.str() << endl;
- }
-
- if ( sFoldingFlag && /*(gOccurrences->getCount(t) > 0) &&*/
- (boxComplexity(t) > 2) && getDefNameProperty(t, id)) {
- char temp[1024];
- getBoxType(t, &ins, &outs);
- stringstream s, l;
- s << tree2str(id);
- l << legalFileName(t,1024,temp) << "." << gDevSuffix;
- scheduleDrawing(t);
- return makeBlockSchema(ins, outs, s.str(), linkcolor, l.str());
-
- } else if (getDefNameProperty(t, id) && ! isPureRouting(t)) {
- // named case : not a slot, with a name
- // draw a line around the object with its name
- stringstream s; s << tree2str(id);
- return makeDecorateSchema(generateInsideSchema(t), 10, s.str());
-
- } else {
- // normal case
- return generateInsideSchema(t);
- }
-}
-
-
-
-/**
- * Generate the inside schema of a block diagram
- * according to its type
- */
-static schema* generateInsideSchema(Tree t)
-{
- Tree a, b, ff, l, type,name,file;
- int i;
- double r;
- prim0 p0;
- prim1 p1;
- prim2 p2;
- prim3 p3;
- prim4 p4;
- prim5 p5;
-
-
- xtended* xt = (xtended*)getUserData(t);
-
- if (xt) { return makeBlockSchema(xt->arity(), 1, xt->name(), normalcolor, ""); }
-
- else if (isInverter(t)) { return makeInverterSchema(invcolor); }
-
- else if (isBoxInt(t, &i)) { stringstream s; s << i; return makeBlockSchema(0, 1, s.str(), numcolor, "" ); }
- else if (isBoxReal(t, &r)) { stringstream s; s << r; return makeBlockSchema(0, 1, s.str(), numcolor, "" ); }
- else if (isBoxWire(t)) { return makeCableSchema(); }
- else if (isBoxCut(t)) { return makeCutSchema(); }
-
- else if (isBoxPrim0(t, &p0)) { return makeBlockSchema(0, 1, prim0name(p0), normalcolor, ""); }
- else if (isBoxPrim1(t, &p1)) { return makeBlockSchema(1, 1, prim1name(p1), normalcolor, ""); }
- else if (isBoxPrim2(t, &p2)) { return makeBlockSchema(2, 1, prim2name(p2), normalcolor, ""); }
- else if (isBoxPrim3(t, &p3)) { return makeBlockSchema(3, 1, prim3name(p3), normalcolor, ""); }
- else if (isBoxPrim4(t, &p4)) { return makeBlockSchema(4, 1, prim4name(p4), normalcolor, ""); }
- else if (isBoxPrim5(t, &p5)) { return makeBlockSchema(5, 1, prim5name(p5), normalcolor, ""); }
-
- else if (isBoxFFun(t, ff)) { return makeBlockSchema(ffarity(ff), 1, ffname(ff), normalcolor, ""); }
- else if (isBoxFConst(t, type,name,file)) { return makeBlockSchema(0, 1, tree2str(name), normalcolor, ""); }
- else if (isBoxFVar (t, type, name,file)) { return makeBlockSchema(0, 1, tree2str(name), normalcolor, ""); }
-
- else if (isBoxButton(t)) { return generateUserInterfaceSchema(t); }
- else if (isBoxCheckbox(t)) { return generateUserInterfaceSchema(t); }
- else if (isBoxVSlider(t)) { return generateUserInterfaceSchema(t); }
- else if (isBoxHSlider(t)) { return generateUserInterfaceSchema(t); }
- else if (isBoxNumEntry(t)) { return generateUserInterfaceSchema(t); }
- else if (isBoxVBargraph(t)) { return generateBargraphSchema(t); }
- else if (isBoxHBargraph(t)) { return generateBargraphSchema(t); }
-
- // don't draw group rectangle when labels are empty (ie "")
- else if (isBoxVGroup(t,l,a)) { stringstream s; s << "vgroup(" << extractName(l) << ")";
- schema* r = generateDiagramSchema(a);
- return makeDecorateSchema(r, 10, s.str()); }
- else if (isBoxHGroup(t,l,a)) { stringstream s; s << "hgroup(" << extractName(l) << ")";
- schema* r = generateDiagramSchema(a);
- return makeDecorateSchema(r, 10, s.str()); }
- else if (isBoxTGroup(t,l,a)) { stringstream s; s << "tgroup(" << extractName(l) << ")";
- schema* r = generateDiagramSchema(a);
- return makeDecorateSchema(r, 10, s.str()); }
-
- else if (isBoxSeq(t, a, b)) { return makeSeqSchema(generateDiagramSchema(a), generateDiagramSchema(b)); }
- else if (isBoxPar(t, a, b)) { return makeParSchema(generateDiagramSchema(a), generateDiagramSchema(b)); }
- else if (isBoxSplit(t, a, b)) { return makeSplitSchema(generateDiagramSchema(a), generateDiagramSchema(b)); }
- else if (isBoxMerge(t, a, b)) { return makeMergeSchema(generateDiagramSchema(a), generateDiagramSchema(b)); }
- else if (isBoxRec(t, a, b)) { return makeRecSchema(generateDiagramSchema(a), generateDiagramSchema(b)); }
-
- else if (isBoxSlot(t, &i)) { return generateOutputSlotSchema(t); }
- else if (isBoxSymbolic(t,a,b)) {
- Tree id;
- if (getDefNameProperty(t, id)) {
- return generateAbstractionSchema(generateInputSlotSchema(a), b);
- } else {
- return makeDecorateSchema(generateAbstractionSchema(generateInputSlotSchema(a), b), 10, "Abstraction");
- }
- }
-
- else {
-
- fprintf(stderr, "Internal Error, box expression not recognized : "); print(t, stderr); fprintf(stderr, "\n");
- exit(1);
-
- }
-}
-
-/**
- * Convert User interface element into a textual representation
- */
-static void UserInterfaceDescription(Tree box, string& d)
-{
- Tree t1, label, cur, min, max, step;
- stringstream fout;
- // user interface
- if (isBoxButton(box, label)) fout << "button(" << extractName(label) << ')';
- else if (isBoxCheckbox(box, label)) fout << "checkbox(" << extractName(label) << ')';
- else if (isBoxVSlider(box, label, cur, min, max, step)) {
- fout << "vslider("
- << extractName(label) << ", "
- << boxpp(cur) << ", "
- << boxpp(min) << ", "
- << boxpp(max) << ", "
- << boxpp(step)<< ')';
- }
- else if (isBoxHSlider(box, label, cur, min, max, step)) {
- fout << "hslider("
- << extractName(label) << ", "
- << boxpp(cur) << ", "
- << boxpp(min) << ", "
- << boxpp(max) << ", "
- << boxpp(step)<< ')';
- }
- else if (isBoxVGroup(box, label, t1)) {
- fout << "vgroup(" << extractName(label) << ", " << boxpp(t1, 0) << ')';
- }
- else if (isBoxHGroup(box, label, t1)) {
- fout << "hgroup(" << extractName(label) << ", " << boxpp(t1, 0) << ')';
- }
- else if (isBoxTGroup(box, label, t1)) {
- fout << "tgroup(" << extractName(label) << ", " << boxpp(t1, 0) << ')';
- }
- else if (isBoxHBargraph(box, label, min, max)) {
- fout << "hbargraph("
- << extractName(label) << ", "
- << boxpp(min) << ", "
- << boxpp(max) << ')';
- }
- else if (isBoxVBargraph(box, label, min, max)) {
- fout << "vbargraph("
- << extractName(label) << ", "
- << boxpp(min) << ", "
- << boxpp(max) << ')';
- }
- else if (isBoxNumEntry(box, label, cur, min, max, step)) {
- fout << "nentry("
- << extractName(label) << ", "
- << boxpp(cur) << ", "
- << boxpp(min) << ", "
- << boxpp(max) << ", "
- << boxpp(step)<< ')';
- }
- else {
- cerr << "INTERNAL ERROR : unknow user interface element " << endl;
- exit(0);
- }
- d = fout.str();
-}
-
-
-/**
- * Generate a 0->1 block schema for a user interface element
- */
-static schema* generateUserInterfaceSchema(Tree t)
-{
- string s; UserInterfaceDescription(t,s);
- return makeBlockSchema(0, 1, s, uicolor, "");
-}
-
-
-/**
- * Generate a 1->1 block schema for a user interface bargraph
- */
-static schema* generateBargraphSchema(Tree t)
-{
- string s; UserInterfaceDescription(t,s);
- return makeBlockSchema(1, 1, s, uicolor, "");
-}
-
-
-
-/**
- * Generate a 1->0 block schema for an input slot
- */
-static schema* generateInputSlotSchema(Tree a)
-{
- Tree id; assert(getDefNameProperty(a, id));
- stringstream s; s << tree2str(id);
- return makeBlockSchema(1, 0, s.str(), slotcolor, "");
-}
-
-
-
-/**
- * Generate a 0->1 block schema for an output slot
- */
-static schema* generateOutputSlotSchema(Tree a)
-{
- Tree id; assert(getDefNameProperty(a, id));
- stringstream s; s << tree2str(id);
- return makeBlockSchema(0, 1, s.str(), slotcolor, "");
-}
-
-
-
-/**
- * Generate an abstraction schema by placing in sequence
- * the input slots and the body
- */
-static schema* generateAbstractionSchema(schema* x, Tree t)
-{
- Tree a,b;
-
- while (isBoxSymbolic(t,a,b)) {
- x = makeParSchema(x, generateInputSlotSchema(a));
- t = b;
- }
- return makeSeqSchema(x, generateDiagramSchema(t));
-}
-
projects / Faustine.git / blobdiff