drawschema.cpp File Reference

Implement block-diagram schema generation in svg or postscript format. More...

#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 "xtended.hh"
#include "eval.hh"
#include "occurrences.hh"
#include "boxcomplexity.h"
#include "schema.h"
#include "drawschema.hh"
#include "compatibility.hh"

Go to the source code of this file.

Functions

static void writeSchemaFile (Tree bd)
 Write a top level diagram.
static schemagenerateDiagramSchema (Tree t)
 Generate an appropriate schema according to the type of block diagram.
static schemagenerateInsideSchema (Tree t)
 Generate the inside schema of a block diagram according to its type.
static void scheduleDrawing (Tree t)
 Schedule a makeBlockSchema diagram to be drawn.
static bool pendingDrawing (Tree &t)
 Retrieve next block diagram that must be drawn.
static schemagenerateAbstractionSchema (schema *x, Tree t)
 Generate an abstraction schema by placing in sequence the input slots and the body.
static schemagenerateOutputSlotSchema (Tree a)
 Generate a 0->1 block schema for an output slot.
static schemagenerateInputSlotSchema (Tree a)
 Generate a 1->0 block schema for an input slot.
static schemagenerateBargraphSchema (Tree t)
 Generate a 1->1 block schema for a user interface bargraph.
static schemagenerateUserInterfaceSchema (Tree t)
 Generate a 0->1 block schema for a user interface element.
static char * legalFileName (Tree t, int n, char *dst)
 Transform the definition name property of tree <t> into a legal file name.
static int cholddir ()
 Switch back to the previously stored current directory.
static int mkchdir (const char *dirname)
 Create a new directory in the current one to store the diagrams.
void drawSchema (Tree bd, const char *projname, const char *dev)
 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>.


Detailed Description

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.

Definition in file drawschema.cpp.


Function Documentation

static schema * generateDiagramSchema ( Tree  t  )  [static]

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.

Definition at line 317 of file drawschema.cpp.

References boxComplexity(), generateInsideSchema(), getBoxType(), getDefNameProperty(), legalFileName(), and scheduleDrawing().

Referenced by generateAbstractionSchema(), and generateInsideSchema().

00318 {
00319     Tree    id;
00320     int     ins, outs;
00321 
00322     //cerr << t << " generateDiagramSchema " << boxpp(t)<< endl;
00323 
00324     if (getDefNameProperty(t, id)) {
00325         stringstream    s; s << tree2str(id);
00326         //cerr << t << "\tNAMED : " << s.str() << endl;
00327     }
00328 
00329     if ( sFoldingFlag && /*(gOccurrences->getCount(t) > 0) &&*/
00330             (boxComplexity(t) > 2) && getDefNameProperty(t, id)) {
00331         char    temp[1024];
00332         getBoxType(t, &ins, &outs);
00333         stringstream s, l;
00334         s << tree2str(id);
00335         l << legalFileName(t,1024,temp) << "." << gDevSuffix;
00336         scheduleDrawing(t);
00337         return makeBlockSchema(ins, outs, s.str(), linkcolor, l.str());
00338 
00339     } else  if (getDefNameProperty(t, id) && ! isBoxSlot(t)) {
00340         // named case : not a slot, with a name
00341         // draw a line around the object with its name
00342         stringstream    s; s << tree2str(id);
00343         return makeDecorateSchema(generateInsideSchema(t), 10, s.str());
00344 
00345     } else {
00346         // normal case
00347         return generateInsideSchema(t);
00348     }
00349 }

static char * legalFileName ( Tree  t,
int  n,
char *  dst 
) [static]

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.

Definition at line 289 of file drawschema.cpp.

References getDefNameProperty().

Referenced by generateDiagramSchema(), and writeSchemaFile().

00290 {
00291     Tree    id;
00292     int     i=0;
00293     if (getDefNameProperty(t, id)) {
00294         const char*     src = tree2str(id);
00295         for (i=0; isalnum(src[i]) && i<16; i++) {
00296             dst[i] = src[i];
00297         }
00298     }
00299     dst[i] = 0;
00300     if (strcmp(dst, "process") != 0) { 
00301         // if it is not process add the hex address to make the name unique
00302         snprintf(&dst[i], n-i, "-%p", t);
00303     }
00304     return dst;
00305 }

static int mkchdir ( const char *  dirname  )  [static]

Create a new directory in the current one to store the diagrams.

The current directory is saved to be later restaured.

Definition at line 252 of file drawschema.cpp.

Referenced by drawSchema().

00253 {
00254     //cerr << "mkchdir of " << dirname << endl;
00255     if (getcwd(gCurrentDir, 512) != 0) {
00256         int status = mkdir(dirname, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
00257         if (status == 0 || errno == EEXIST) {
00258             if (chdir(dirname) == 0) {
00259                 return 0;
00260             }
00261         }
00262     }
00263     perror("mkchdir");
00264     exit(errno);
00265     //return errno;
00266 }

static void writeSchemaFile ( Tree  bd  )  [static]

Write a top level diagram.

A top level diagram is decorated with is definition name property and is drawn in an individual file

Definition at line 215 of file drawschema.cpp.

References schema::draw(), generateInsideSchema(), getDefNameProperty(), schema::height(), legalFileName(), schema::place(), and schema::width().

Referenced by drawSchema().

00216 {
00217     Tree            id;
00218     schema*         ts;
00219 
00220     char            temp[1024];
00221 
00222     gOccurrences = new Occurrences(bd);
00223 
00224     bool hasname = getDefNameProperty(bd, id); assert(hasname);
00225 
00226     // generate legal file name for the schema
00227     stringstream s1; s1 << legalFileName(bd, 1024, temp) << "." << gDevSuffix;
00228     gSchemaFileName = s1.str();
00229 
00230     // generate the label of the schema
00231     stringstream s2; s2 << tree2str(id);
00232     string link = gBackLink[bd];
00233     ts = makeTopSchema(generateInsideSchema(bd), 20, s2.str(), link);
00234     // draw to the device defined by gDevSuffix
00235     if (strcmp(gDevSuffix, "svg") == 0) {
00236         SVGDev dev(s1.str().c_str(), ts->width(), ts->height());
00237         ts->place(0,0, kLeftRight);
00238         ts->draw(dev);
00239     } else {
00240         PSDev dev(s1.str().c_str(), ts->width(), ts->height());
00241         ts->place(0,0, kLeftRight);
00242         ts->draw(dev);
00243     }
00244 }


Generated on Sun Mar 22 16:24:21 2009 for FAUST compiler by  doxygen 1.5.7.1