colorize.cpp

Go to the documentation of this file.

#include "colorize.h"
#include "signals.hh"

using namespace std; 

// static funvtions needed to implement splitDependance

static int allocateColor(Tree exp);                         
static void colorize(Tree exp, int color);                  
static void uncolorize(Tree exp);                           
static void listMultiColoredExp(Tree exp, set<Tree>& lst);  



void splitDependance(const set<Tree>& exps, set<Tree>& post, set<Tree>& pre)
{
    set<Tree>::const_iterator e;
    for (e= exps.begin(); e != exps.end(); e++) {
        colorize(*e, allocateColor(*e));
    }
    
    pre.clear();
    for (e = exps.begin(); e != exps.end(); e++) {
        listMultiColoredExp(*e, pre);
    }
    
    post.clear();
    set_difference(exps.begin(), exps.end(), pre.begin(), pre.end(), inserter(post, post.begin()));
    
    for (e = exps.begin(); e != exps.end(); e++) {
        uncolorize(*e);
    }
}

//------------------------------------------- IMPLEMENTATION  (level 1)-----------------------------------------------------

static void addColor(Tree exp, int color);                  
static bool hasColor(Tree exp, int color);                  
static int colorsCount(Tree exp);                           
static void clearColors(Tree exp);                          

int allocateColor(Tree exp)
{
//  return int(exp); 
    static map<Tree,int> colorMap;
    static int nextFreeColor = 1;
    int& color = colorMap[exp];
    if (!color)
        color = nextFreeColor++;
    return color;
}

void colorize(Tree exp, int color)
{
    if (! hasColor(exp, color)) {
        addColor(exp, color);
        vector<Tree> v;
        int n = getSubSignals(exp, v, false);
        for (int i=0; i<n; i++) colorize(v[i], color);
    }   
}

void uncolorize(Tree exp)
{
    if (colorsCount(exp) > 0) {
        clearColors(exp);
        vector<Tree> v;
        int n = getSubSignals(exp, v, false);
        for (int i=0; i<n; i++) uncolorize(v[i]);
    }   
}

void listMultiColoredExp(Tree exp, set<Tree>& lst)
{
    assert(colorsCount(exp) > 0);
    if (colorsCount(exp) > 1) {
        // we have found a multicolored expression
        lst.insert(exp);
    } else {
        // it is a monocolored expression
        // we search its subexpressions
        vector<Tree> v;
        int n = getSubSignals(exp, v, false);
        for (int i=0; i<n; i++) {
            listMultiColoredExp(v[i], lst);
        }
    }   
}

//------------------------------------------- IMPLEMENTATION  (level 2)-----------------------------------------------------

Tree COLORPROPERTY = tree(symbol("ColorProperty"));

void setColorProperty(Tree sig, set<int>* colorset)
{
    setProperty(sig, COLORPROPERTY, tree((void*)colorset));
}


set<int>* getColorProperty(Tree sig)
{
    Tree tt;
    if (!getProperty(sig, COLORPROPERTY, tt)) {
        return 0;
    } else {
        return (set<int>*)tree2ptr(tt);
    }
}




void addColor(Tree exp, int color)
{
    set<int>* cset = getColorProperty(exp);
    if (cset == 0) {
        cset = new set<int>();
        setColorProperty(exp, cset);
    }
    cset->insert(color);
}


bool hasColor(Tree exp, int color)
{
    set<int>* cset = getColorProperty(exp);
    if (cset==0) {
        return false;
    } else {
        return cset->find(color) != cset->end();
    }
}


static int colorsCount(Tree exp)
{
    set<int>* cset = getColorProperty(exp);
    if (cset==0) {
        return 0;
    } else {
        return cset->size();
    }
}


static void clearColors(Tree exp)
{
    set<int>* cset = getColorProperty(exp);
    if (cset != 0) {
        cset->clear();
    }
}