/home/ythoma/docs/math2mat/svn/wp1/framework/m2mGUI/src/m2m/backend/structure/StructTreatment.java

Go to the documentation of this file.

/******************************************************************************
 *                                                                                      StructTreatment
 ******************************************************************************
 * Auteur               : Trolliet Gregory
 * Date                 : 4 mars 2009
 * Description :
 ******************************************************************************/
package m2m.backend.structure;

import org.w3c.dom.*;

import m2m.backend.buildingblocks.BuildingBlock;
import m2m.backend.buildingblocks.BuildingBlock.NumType;

import java.util.Vector;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileWriter;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.FileInputStream;
import java.util.Calendar;
import java.util.Iterator;
import java.util.StringTokenizer;
import java.util.HashMap;
import java.util.ArrayList;



import m2m.backend.octaveparser.*;
import m2m.backend.project.ProjectRef;
import m2m.backend.utils.FileUtils;
import m2m.backend.utils.XMLUtils;
import m2m.backend.vhdl.*;

public class StructTreatment extends ProjectRef 
{       
        private int tmpCpt;
        private int opCpt;
        private Function top;
        private Vector<String> negList;
        private HashMap<String, String> pragmaMap;
        private HashMap<String, SimpleVariable> varMap;
        public static final String TMP_NAME = "m2mtmp"; 
        private int nbMonitor = 0;
        private long parseTime;
        
        private String sourceMd5;
        
        private String sourceCode;
        
        public StructTreatment() {
                this.tmpCpt = 0;
                this.opCpt = 0;
                this.top = null;
                this.negList = new Vector<String>();
                this.pragmaMap = new HashMap<String, String>();
                this.varMap = new HashMap<String, SimpleVariable>();
                this.nbMonitor=0;
        }
        

        @SuppressWarnings("unchecked")
        public StructTreatment copy() {
                StructTreatment clone=new StructTreatment();
                clone.tmpCpt=this.tmpCpt;
                clone.opCpt=this.opCpt;
                clone.top=new Function();
                clone.top=(Function)this.top.copy(null);
                clone.negList = (Vector<String>)this.negList.clone();
                clone.pragmaMap = (HashMap<String, String>)this.pragmaMap.clone();
                clone.varMap = (HashMap<String, SimpleVariable>)this.varMap.clone();
                clone.nbMonitor = this.nbMonitor;
                return clone;
        }
        
        public void modifyNumType(NumType type) {
                top.modifyNumType(type);
        }
        
        public long getParseTime() {
                return parseTime;
        }

        public void setTop(Function top) {
                this.top = top;
        }

        public Function getTop() {
                return this.top;
        }

        public Vector<Element> getInput() {
                return ((Function) this.top).getInput();
        }
                
        public Vector<Element> getOutput() {
                return ((Function) this.top).getOutput();
        }

        public String getName() {
                return top.getName();
        }

        public void parse(File file) throws ParsingException 
        {
                InputStream in = null;
                try {
                        in = new FileInputStream(file.getPath());
                } catch (FileNotFoundException e) {
                        System.out.println("Le fichier n'existe pas!");
                        e.printStackTrace();
                        System.exit(0);
                } catch (SecurityException e) {
                        e.printStackTrace();
                }

                OctaveLexer lexer = new OctaveLexer(in);
                OctaveParser parser = new OctaveParser(lexer);
                // Create the top entity of the structure
                this.top = new Function();
                parser.setTop(this.top);
                parser.setTreat(this);
                try {
                        parser.entry();
                        if (!parser.isSuccessful())
                                throw new ParsingException("Parsing error");
                        this.treeToVector();
                        this.postParse(top);
                        Calendar cal = Calendar.getInstance();
                        parseTime = cal.getTime().getTime();
//                      long timeCurrent = cal.getTime().getTime() / 100000;
                } catch (Exception e) {
                        throw new ParsingException(e);
                }
                sourceMd5=FileUtils.getMd5(file.getAbsolutePath());

                sourceCode = FileUtils.readFileAsString(file.getAbsolutePath());
        }
        public void parseNoFlat(File file) throws ParsingException 
        {
                InputStream in = null;
                try {
                        in = new FileInputStream(file.getPath());
                } catch (FileNotFoundException e) {
                        System.out.println("Le fichier n'existe pas!");
                        e.printStackTrace();
                        System.exit(0);
                } catch (SecurityException e) {
                        e.printStackTrace();
                }

                OctaveLexer lexer = new OctaveLexer(in);
                OctaveParser parser = new OctaveParser(lexer);
                // Create the top entity of the structure
                this.top = new Function();
                parser.setTop(this.top);
                parser.setTreat(this);
                try {
                        parser.entry();
                        if (!parser.isSuccessful())
                                throw new ParsingException("Parsing error");
                        //OptimizeOperators opt=new OptimizeOperators(this);
                        //opt.optimise();
                        this.postParse(top);
                        Calendar cal = Calendar.getInstance();
                        parseTime = cal.getTime().getTime();
//                      long timeCurrent = cal.getTime().getTime() / 100000;
                } catch (Exception e) {
                        throw new ParsingException(e);
                }
                sourceMd5=FileUtils.getMd5(file.getAbsolutePath());

                sourceCode = FileUtils.readFileAsString(file.getAbsolutePath());
        }
        
        public String getSourceMd5() {
                return sourceMd5;
        }
        
        public String getSourceCode() {
                return sourceCode;
        }
        
        public void parse(String code) throws ParsingException 
        {

                InputStream in = null;
                in = new ByteArrayInputStream(code.getBytes());
                
                OctaveLexer lexer = new OctaveLexer(in);
                OctaveParser parser = new OctaveParser(lexer);
                // Create the top entity of the structure
                this.top = new Function();
                parser.setTop(this.top);
                parser.setTreat(this);
                try {
                        parser.entry();
                        if (!parser.isSuccessful())
                                throw new ParsingException("Parsing error");
                //      OptimizeOperators opt=new OptimizeOperators(this);
                //      opt.optimise();
                        this.treeToVector();
                        this.postParse(top);
                        Calendar cal = Calendar.getInstance();
                        parseTime = cal.getTime().getTime();
                } catch (Exception e) {
                        throw new ParsingException(e);
                }
                sourceMd5=FileUtils.getStringMd5(code);
                sourceCode=code;
        }

        public Vector<Element> createOp(
                          Vector<Element> a, Vector<Element> b, Operation op) {
                Vector<Element> vec = new Vector<Element>();
                // Add all the elements of a and remove the last. That's the one to
                // treat.
                vec.addAll(a);
                vec.remove(vec.lastIndexOf(a.lastElement()));
                if (a.lastElement() instanceof Negation) {
                        vec.add(a.lastElement());
                        op.addInput(((Negation) a.lastElement()).getOutputAt(0));
                } else {
                        op.addInput(a.lastElement());
                }
                // Same operation that with a
                vec.addAll(b);
                vec.remove(vec.lastIndexOf(b.lastElement()));
                if (b.lastElement() instanceof Negation) {
                        vec.add(b.lastElement());
                        op.addInput(((Negation) b.lastElement()).getOutputAt(0));
                } else {
                        op.addInput(b.lastElement());
                }
                op.setName(op.getName() + this.getNextOpCpt());
                vec.add(op);
                if (op instanceof DotDivision || op instanceof DotMultiplication) {
                        for (Element e : op.getInput()) {
                                if (e instanceof Variable) {
                                        this.addPragma(getTrueName(e.getName()), "vector");
                                }
                        }
                }
                return vec;
        }

        public Vector<Element> createNot(Vector<Element> a, Not not) {
                Vector<Element> vec = new Vector<Element>();
                vec.addAll(a);
                vec.remove(vec.lastIndexOf(a.lastElement()));
                if (a.lastElement() instanceof Negation) {
                        vec.add(a.lastElement());
                        not.addInput(((Operation) a.lastElement()).getOutputAt(0));
                } else {
                        not.addInput(a.lastElement());
                }
                vec.add(not);
                return vec;
        }

        public int getNextOpCpt() {
                return this.opCpt++;
        }

        public void treeToVector() {
                this.treeToVector(top);
        }

        public void treeToVector(Function parent) {
                parent.setBody(this.convertBody(parent.getBody(), parent));
                if (parent instanceof LoopWhile) {
                        ((LoopWhile) parent).setCond(this.convertBody(((LoopWhile) parent).getCond(), parent));
                }
        }

        private Vector<Element> convertBody(Vector<Element> vec, Element parent) {
                Vector<Element> newel = new Vector<Element>();
                if (vec == null || vec.isEmpty()) {
                        return vec;
                }
                for (Element e : vec) {
                        if (e instanceof Operation) {
                                newel.addAll(this.convertOperation((Operation) e, parent));
                        } 
                        else if (e instanceof Switch) { 
                                Switch sw = (Switch) parent;
                                for (Case c : sw.getCases()) {
                                        c.setBody(this.convertBody(c.getBody(), parent));
                                }
                        }
                        else if (e instanceof IfThenElse) { 
                                newel.add(e);
                                IfThenElse ite = (IfThenElse) e;
                                ite.setBodyTrue(this.convertBody(ite.getBodyTrue(), ite));
                                ite.setBodyFalse(this.convertBody(ite.getBodyFalse(), ite));
                                ite.setCond(this.convertBody(ite.getCond(), ite));
                                for(Element element : ite.internalVars) {
                                        if(!((Function)parent).internalVars.contains(element))
                                                ((Function)parent).internalVars.add(element);
                                }
                        }
                        else if(e instanceof Function ) {
                                newel.add(e);
                                treeToVector((Function) e);
                        }
                }
                return newel;
        }

        private Vector<Element> convertOperation(Operation op, Element parent) {
                Vector<Element> vec = new Vector<Element>();
                Vector<Element> input;
                SimpleVariable tmp;
                input = op.getInput();
                op.setInput(new Vector<Element>());
                for (Element e : input) {
                        if (e instanceof Operation) {
                                vec.addAll(this.convertOperation((Operation) e, parent));
                                // if operation need to be separate, create a temporary value
                                tmp = new SimpleVariable(TMP_NAME + "_m2m_" + tmpCpt++);
                                ((Operation) e).addOutput(tmp);
                                ((Function)parent).addInternalVar(tmp);
                                op.addInput(tmp);
                        } else if (e instanceof Variable) {
                                op.addInput(e);
                        }
                }
                vec.add(op);
                return vec;
        }

        public Vector<Element> createAff(Variable var, Vector<Element> expr) {
                Vector<Element> vec = new Vector<Element>();
                Operation result = new Assignment();
                if (expr.lastElement() instanceof Variable) {
                        // Add all element of expr to vec except the last one
                        vec.addAll(expr);
                        vec.removeElementAt(vec.lastIndexOf(expr.lastElement()));
                        // If that's a SimpleVariable, juste add to the assignment
                        result.addInput((Variable) expr.lastElement());
                        result.setName("aff" + this.opCpt++);
                        var.setType(((Variable) expr.lastElement()).getType());
                        if (var instanceof SimpleVariable) {
                                ((SimpleVariable) var).setSize(((Variable) expr.lastElement()).getSize());
                        }
                        if (((Variable) expr.lastElement()).getType().equals("const")) {
                                ((SimpleVariable) var).setVal((((Variable) expr.lastElement()).getVal()));
                        }
                } else if (expr.lastElement() instanceof Negation) {
                        // Add all elements of expr to vec
                        vec.addAll(expr);
                        result.addInput(((Negation) expr.lastElement()).getOutputAt(0));
                        result.setName("aff" + this.opCpt++);
                        var.setType(((Variable) ((Negation) expr.lastElement()).getOutputAt(0)).getType());
                } else if (expr.lastElement() instanceof Operation) {
                        vec.addAll(expr);
                        vec.removeElementAt(vec.lastIndexOf(expr.lastElement()));
                        result = ((Operation) expr.lastElement());
                        //var.setType(((Variable)((Operation)expr.lastElement()).getOutputAt(0)).getType());
                }
                result.addOutput(var);
                vec.add(result);
                return vec;
        }

        public SimpleVariable createInOut(String name) {
                SimpleVariable var = null;
                if (this.varMap.containsKey(name)) {
                        var = this.varMap.get(name);
                } else {
                        var = new SimpleVariable(name);
                        this.varMap.put(name, var);
                }
                if (this.pragmaMap.containsKey(getTrueName(name))) {
                        ((SimpleVariable) var).setType(this.pragmaMap.get(getTrueName(name)));
                }
                return var;
        }

        public Vector<Element> createVar(String name, ArrayList<Double> val,
                          String type,int size, boolean minus) {
                //int size = val.size();
                SimpleVariable var = null;
                Vector<Element> vec = new Vector<Element>();
                if (name.isEmpty()) {
                        // If it as no name, it don't exist so we simply create
                        vec.add(new SimpleVariable(val));
                } else if (minus && !negList.contains(name)) {
                        Negation neg = null;
                        // If it's negative and never declared before
                        neg = new Negation();
                        var = (SimpleVariable) this.createVar(getTrueName(name) + "_m2m_n",
                                          0.0, "", false).lastElement();
                        if (this.pragmaMap.containsKey(name)) {
                                var.setType(this.pragmaMap.get(name));
                        }
                        neg.addOutput(var);
                        neg.addInput(this.createVar(name, 0.0, "", false).lastElement());
                        neg.setName("neg" + this.opCpt++);
                        this.negList.add(name);
                        vec.add(neg);
                        vec.add(var);
                } else if (minus) {
                        // If negative and already declared
                        vec.add(this.createVar(name + "_m2m_n", 0.0, "", false).lastElement());
                } else {
                        // If normal variable
                        if (this.varMap.containsKey(name)) {
                                var = this.varMap.get(name);
                        } else {
                                var = new SimpleVariable(name, val, type);
                                var.setSize(size);
                                this.top.addInternalVar(var);
                                this.varMap.put(name, var);
                        }
                        if (this.pragmaMap.containsKey(getTrueName(name))) {
                                ((SimpleVariable) var).setType(this.pragmaMap.get(getTrueName(name)));
                        }
                        vec.add(var);
                }
                return vec;
        }

        public static String getTrueName(String name) {
                StringTokenizer st = new StringTokenizer(name, "_");
                String trueName = new String();
                String tmp = new String();
                if (st.hasMoreTokens()) {
                        trueName = st.nextToken();
                }
                while (st.hasMoreTokens()) {
                        tmp = st.nextToken();
                        if (tmp.equals("m2m")) {
                                return trueName;
                        }
                        trueName += "_" + tmp;
                }
                return trueName;
        }

        public Vector<Element> createSimpleVar(SimpleVariable var) {
                return this.createVar(var.getName(), var.getValues(), var.getType(), var.getSize(), false);
        }

        public Vector<Element> createVar(Variable var) {
                Vector<Element> vec = null;
                if (var instanceof VectorVariable) {
                        vec = this.createVar(((VectorVariable) var).getVar());
                } else if (var instanceof SimpleVariable) {
                        vec = this.createSimpleVar((SimpleVariable) var);
                }
                return vec;
        }

        public Vector<Element> createVar(String name, double val,
                          String type, boolean minus) {
                ArrayList<Double> values = new ArrayList<Double>();
                values.add(val);
                return this.createVar(name, values, type, 1, minus);
        }

        public Vector<Element> createVar(String name) {
                ArrayList<Double> values = new ArrayList<Double>();
                //values.add(0.0);
                return this.createVar(name, values, "", 0, false);
        }

        public void count(Element el) {
                el.setName(el.getName() + this.opCpt++);
        }

        public void createInOutAff(Function top, HashMap<String, ReadWriteIndex> map) {
                Assignment aff;
                String name;
                int cpt = 0;
                if (top == null) {
                        top = this.top;
                }
                // Input aff
                for (Element var : top.getInput()) {
                        name = var.getName();
                        if (this.varMap.containsKey(name + "_m2m_0")) {
                                aff = new Assignment();
                                aff.setName("aff_final_" + cpt++);
                                aff.addInput(var);
                                aff.addOutput(this.varMap.get(name + "_m2m_0"));
                                top.addBodyToTop(aff);
                        } else {
                                aff = new Assignment();
                                aff.setName("aff_final_" + cpt++);
                                Variable tmp = (Variable) this.createVar(name + "_m2m_0", 0.0, "", false).lastElement();
                                aff.addInput(var);
                                aff.addOutput(tmp);
                                top.addBodyToTop(aff);
                        }
                }
                // Output aff
                for (Element var : top.getOutput()) {
                        name = var.getName();
                        if(map.containsKey(name))
                        if (this.varMap.containsKey(name + "_m2m_" + ((ReadWriteIndex)map.get(name)).getReadIndex())) {
                                aff = new Assignment();
                                aff.setName("aff_final_" + cpt++);
                                aff.addInput(this.varMap.get(name + "_m2m_" +((ReadWriteIndex)map.get(name)).getReadIndex()));
                                aff.addOutput(var);
                                top.addBody(aff);
                        }
                }
        }

        public void addPragma(String pragma) {
                StringTokenizer st = new StringTokenizer(pragma, " :\t");
                String name = null;
                String type = null;
                if (st.countTokens() == 3 & st.nextToken().equals("%m2m")) {
                        name = st.nextToken();
                        type = st.nextToken();
                        //System.out.println(name+"\t"+type);
                        this.pragmaMap.put(name, type);
                        this.changeType(this.top, name, type);
                        //System.out.println("Nombre d'occurences de la variable modifiée :"
                        //                + this.changeType(this.top, name, type));
                } else {
                        System.out.println("#Le pragma ne respecte pas le standard!");
                }
        }

        public void addPragma(String name, String type) {
                this.pragmaMap.put(name, type);
                this.changeType(this.top, name, type);
                System.out.println("Nombre d'occurences de la variable modifiée :" + this.changeType(this.top, name, type));
        }

        private int changeType(Element top, String name, String type) {
                int nb = 0;
                if (top instanceof Function) {
                        if (top instanceof LoopFor) {
                                nb += this.changeType(((LoopFor) top).getStart(), name, type);
                                nb += this.changeType(((LoopFor) top).getIncr(), name, type);
                                nb += this.changeType(((LoopFor) top).getEnd(), name, type);
                        }
                        for (Element el : ((Function) top).getInput()) {
                                nb += this.changeType(el, name, type);
                        }
                        for (Element el : ((Function) top).getOutput()) {
                                nb += this.changeType(el, name, type);
                        }
                        for (Element el : ((Function) top).getInternalVars()) {
                                nb += this.changeType(el, name, type);
                        }
                        for (Element el : ((Function) top).getBody()) {
                                nb += this.changeType(el, name, type);
                        }
                } else if (top instanceof Operation) {
                        for (Element el : ((Operation) top).getInput()) {
                                nb += this.changeType(el, name, type);
                        }
                        for (Element el : ((Operation) top).getOutput()) {
                                nb += this.changeType(el, name, type);
                        }
                } else if (top instanceof SimpleVariable) {
                        if (getTrueName(top.getName()).equals(name)) {
                                ((SimpleVariable) top).setType(type);
                                return 1;
                        }
                } else if (top instanceof VectorVariable) {
                        if (getTrueName(top.getName()).equals(name)) {
                                ((SimpleVariable) ((VectorVariable) top).getVar()).setType(type);
                                return 1;
                        }
                }
                return nb;
        }

        public void changeVar(Element top, Variable varin, Variable varout) {
                if (top instanceof Function) {
                        for (Element el : ((Function) top).getBody()) {
                                this.changeVar(el, varin, varout);
                        }
                        while (((Function) top).getInput().indexOf(varin) != -1) {
                                ((Function) top).getInput().set(((Function) top).getInput().indexOf(varin), varout);
                        }
                        while (((Function) top).getOutput().indexOf(varin) != -1) {
                                ((Function) top).getOutput().set(((Function) top).getOutput().indexOf(varin), varout);
                        }
                        if (top instanceof IfThenElse) {
                                for (Element el : ((IfThenElse) top).getCond()) {
                                        this.changeVar(el, varin, varout);
                                }
                                for (Element el : ((IfThenElse) top).getBodyTrue()) {
                                        this.changeVar(el, varin, varout);
                                }
                                for (Element el : ((IfThenElse) top).getBodyFalse()) {
                                        this.changeVar(el, varin, varout);
                                }
                        }
                } else if (top instanceof Operation) {
                        while (((Operation) top).getInput().indexOf(varin) != -1) {
                                ((Operation) top).getInput().set(((Operation) top).getInput().indexOf(varin), varout);
                        }
                        while (((Operation) top).getOutput().indexOf(varin) != -1) {
                                ((Operation) top).getOutput().set(((Operation) top).getOutput().indexOf(varin), varout);
                        }
                }
        }

        public void findInBody(Element top, HashMap<String, ReadWriteIndex> cpt) {
                HashMap<String, Integer> list = new HashMap<String, Integer>();
                if (top instanceof LoopFor) {
                        for (Element el : ((LoopFor) top).getBody()) {
                                if (el instanceof Operation) {
                                        for (Element in : ((Operation) el).getInput()) {
                                                String name = getTrueName(in.getName());
                                                if (in instanceof Variable
                                                                  & !((Variable) in).getType().equals("const")
                                                                  & !((Variable) in).getType().equals("iter")
                                                                  & !((LoopFor) top).getInput().contains(in)
                                                                  & !name.equalsIgnoreCase(TMP_NAME)) {
                                                        list.put(name, ((ReadWriteIndex)cpt.get(name)).getReadIndex());
                                                }
                                        }
                                } else if (el instanceof Function) {
                                        for (Element in : ((Function) el).getInput()) {
                                                String name = getTrueName(in.getName());
                                                if (in instanceof Variable
                                                                  & !((LoopFor) top).getInput().contains(in)
                                                                  & !name.equalsIgnoreCase(TMP_NAME) 
                                                                  & !((Variable) in).getType().equals("iter")) {
                                                        list.put(name, ((ReadWriteIndex)cpt.get(name)).getReadIndex());
                                                        //((LoopFor) top).addInput(in);
                                                }
                                        }
                                }
                        }
                }

                for (String s : list.keySet()) 
                {
                        Element e = this.createVar(s + "_m2m_" + ((ReadWriteIndex)cpt.get(s)).getReadIndex()).lastElement();
                        if(!((LoopFor) top).getInput().contains(e) && ((Variable) e).getType().equals("iter"))
                                ((LoopFor) top).addInput(e);
                }
        }

        public boolean isVariable(String name) {
                for (String var : this.varMap.keySet()) {
                        if (getTrueName(var).equals(name)) {
                                return true;
                        }
                }
                return false;
        }

        public Vector<Variable> monitoredVar() {
                Vector<Variable> vec = new Vector<Variable>();
                for (SimpleVariable var : varMap.values()) {
                        if (var.monitor) {
                                vec.add(var);
                        }
                }
                return vec;
        }

        public void setBlock(Element top, String opName, BuildingBlock block) {
                if (top instanceof Function) {
                        for (Element el : ((Function) top).getBody()) {
                                this.setBlock(el, opName, block);
                        }
                } else if (top instanceof Operation) {
                        if (((Operation) top).getOpName().equals(opName)) {
                                ((Operation) top).setBlock(block);
                        }
                }
        }

        public boolean writeVHDL(String vhdlPath) {
                File file = new File(vhdlPath+this.top.getName()+".vhd");
                FileWriter fw = null;
                try {
                        // Intialization of the cost of all SimpleVariable
                        setCost(this.top);

                        fw = new FileWriter(file);
                        String sVhdl = new String();
                        
                        VHDLCreator vhdl = new VHDLCreator(this.top, project);
                        vhdl.wrapTop(vhdlPath);
                        sVhdl = vhdl.createVHDL(file.getName());        
                        
                        fw.write(sVhdl);
                        fw.close();

                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                        return false;
                } catch (IOException e) {
                        e.printStackTrace();
                        return false;
                } catch (VHDLException e) {
                        System.out.println("#Unable to create VHDL file! "+e.getMessage());
                        return false;
                }
                System.out.println("VHDL file written!");
                return true;
        }

        public void print() {
                System.out.println(this.top.toString(0));
        }

        public boolean writeSchematic(String outFile) {
                File file = new File(outFile);
                FileWriter fw;
                try {
                        fw = new FileWriter(file);
                        String str = this.createSchematic();
                        fw.write(str);
                        fw.close();
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                        return false;
                } catch (IOException e) {
                        e.printStackTrace();
                        return false;
                }
                System.out.println("Schematic file written!");
                return true;
        }

        private String createSchematic() {
                String sSchema = new String();
                sSchema += "digraph G  {\n";
                sSchema += top.toSchematic(1, "", GraphParams.defaultShape, "");
                sSchema += "\n}";
                return sSchema;
        }

        public void writeOctaveFile() {
                this.writeOctaveFile(null);
        }

        public boolean writeOctaveFile(String outFile) {
                File file;
                if (outFile == null) {
                        file = new File("test/" + this.top.getName() + ".m");
                        System.out.println(file.getName());
                } else {
                        file = new File(outFile);
                }
                FileWriter fw;
                try {
                        fw = new FileWriter(file);
                        String str = this.createOctave();
                        fw.write(str);
                        fw.close();
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                        return false;
                } catch (IOException e) {
                        e.printStackTrace();
                        return false;
                }
                System.out.println("Octave file written!");
                return true;
        }

        private String createOctave() {
                String sOctave = new String();
                sOctave += this.top.toOctave(0);
                return sOctave;
        }
        
        
        public void clean(Vector<Element> body, Vector<Element> varVector) 
        {       
                Vector<Function> functionVector = new Vector<Function>();
                Element element;
                Vector<Element> elementList = new Vector<Element>();
                Iterator<Element> iterElement;
                Element tempElement;
                
                /* Get all children functions and read simple variable */
                elementList.addAll(body);
                iterElement = elementList.iterator();
                while (iterElement.hasNext()) 
                {
                        element = iterElement.next();
                        
                        if (element instanceof Operation) {
                                varVector.add(((Operation)element).getInputAt(0));                      
                                if(((Operation)element).getInput().size() > 1) {
                                        tempElement = ((Operation)element).getInputAt(1);               
                                        if(tempElement instanceof Operation)    
                                                elementList.add(tempElement);
                                        else
                                                varVector.add(tempElement);
                                }
                        }
                        else if (element instanceof Function) {
                                varVector.addAll(((Function)element).getInput());
                                functionVector.add((Function)element);  
                        }
                                        
                        
                        elementList.remove(elementList.indexOf(element));
                        iterElement = elementList.iterator();   
                }
                
                /* Clean all children function */
                Vector<Element> tmpVarVector = new Vector<Element>();
                for(Function function : functionVector)
                {
                        for(Element variable : function.outputVars)
                        {
                                if(!varVector.contains(variable))
                                        tmpVarVector.add(variable);     
                        }       
                        function.outputVars.removeAll(tmpVarVector);
                        if(function instanceof IfThenElse)
                        {
                                clean(((IfThenElse)function).getBodyTrue() , varVector); 
                                clean(((IfThenElse)function).getBodyFalse() , varVector); 
                        }
                        else
                                clean(function.body, varVector); 
                }
        }
        
        public void updateConditionsFor(HashMap<String, ReadWriteIndex> tmpVar, HashMap<String, ReadWriteIndex> cptVar, LoopFor loopFor) 
        {       
                /* Update the end simple variable if it's used into the loop */
                String name = getTrueName(loopFor.getEnd().getName());
                if(cptVar.get(name) != null && ((ReadWriteIndex)tmpVar.get(name)).getReadIndex() != ((ReadWriteIndex)cptVar.get(name)).getReadIndex()-1)
                        loopFor.setEnd((SimpleVariable)createVar(name +"_m2m_"+(((ReadWriteIndex)cptVar.get(name)).getReadIndex())).lastElement());
                
                /* Update the increment simple variable if it's used into the loop */
                name = getTrueName(loopFor.getIncr().getName());
                if(cptVar.get(name) != null && ((ReadWriteIndex)tmpVar.get(name)).getReadIndex() != ((ReadWriteIndex)cptVar.get(name)).getReadIndex()-1)
                        loopFor.setIncr((SimpleVariable)createVar(name +"_m2m_"+(((ReadWriteIndex)cptVar.get(name)).getReadIndex())).lastElement());
        }
        
        
        public void updateConditionsWhile(HashMap<String, ReadWriteIndex> tmpVar, HashMap<String, ReadWriteIndex> cptVar, LoopWhile loopWhile) 
        {       
                String name;
                Element e;
                
                /* Go throught all operation of the condition */
                for(Element op : loopWhile.getCond())
                {
                        /* Udate the first input of the operation */
                        for(int i = 0; i < ((Operation)op).getInput().size(); i++)
                        {
                                e = ((Operation)op).getInputAt(i);
                                name = getTrueName(e.getName());
                                if(cptVar.get(name) != null && !name.equals(TMP_NAME) && ((ReadWriteIndex)tmpVar.get(name)).getReadIndex() != ((ReadWriteIndex)cptVar.get(name)).getReadIndex()-1)
                                        ((Operation)op).setInputAt(i, ((SimpleVariable)createVar(name +"_m2m_"+(((ReadWriteIndex)cptVar.get(name)).getReadIndex())).lastElement()));
                        }
                }
        }
        
        
        private void setCost(Function func)
        {
                /* Initialize the cost of input varaible */
                for(Element e : func.getInput())
                        ((SimpleVariable)e).setCost(0);

                // Set set the cost of body elements
                func.setMaxCost(setCost(func.getBody()));
        }
        
        private int setCost(Vector<Element> elements)
        {
                int maxCost = 0;
                int tempMaxCost = 0;
                
                for(Element e : elements) {
                        if(e instanceof Operation)
                                tempMaxCost = setCost((Operation)e);
                        else if(e instanceof IfThenElse)
                                tempMaxCost = setCost((IfThenElse)e);
                        else if (e instanceof LoopFor) {
                                LoopFor loop = (LoopFor)e;
                                tempMaxCost = setCost(((LoopFor)e).getBody());
                                ((SimpleVariable)loop.getIterOperation().getOutputAt(0)).setCost(loop.getIterOperation().getBlock().latencyTime()+1);
                                loop.setMaxCost(tempMaxCost);
                                loop.setRelativeMaxCost();
                        }
                        
                        maxCost = maxCost < tempMaxCost ? tempMaxCost : maxCost;
                }                       
                
                return maxCost;
        }
        
        private int setCost(Operation op)
        {
                int maxCost = 0;
                int tmpCost = 0;
                Vector<SimpleVariable> inputs = new Vector<SimpleVariable>();
                Vector<Vector<Element>> variablesDependencies = new Vector<Vector<Element>>();
                Vector<Element> resultDependencies = new Vector<Element>();
                
                /* Initialisation of inputs */
                for(int i = 0; i < op.getInput().size(); i++)
                        inputs.add((SimpleVariable) op.getInputAt(i));
                if(op instanceof Multiplexer)
                        inputs.add((SimpleVariable)((Multiplexer)op).getSel());
                        
                /* Get the maximum input cost */
                for(int i = 0; i < inputs.size(); i++) {
                        SimpleVariable sv = inputs.elementAt(i);
                        variablesDependencies.add(sv.getVariableDependencies());
                        variablesDependencies.elementAt(i).add(sv);
                        
                        if(op.getBlock() == null) {
                                maxCost = sv.getCost();
                                break;
                        } else {
                                tmpCost = sv.getCost() + op.getBlock().latencyTime() + 1;
                                maxCost = tmpCost > maxCost ? tmpCost : maxCost;
                        }
                }       
                
                /* Create result variable dependencies */
                for(int i = 0; i < variablesDependencies.size(); i++) {
                        for(int j = 0; j < variablesDependencies.elementAt(i).size(); j++) {
                                if(!resultDependencies.contains(variablesDependencies.elementAt(i).elementAt(j)))
                                        resultDependencies.add(variablesDependencies.elementAt(i).elementAt(j));
                        }
                }
                        
                /* Set the maximum latency cost of outputs */
                for(Element e : op.getOutput()) {
                        ((SimpleVariable)e).setCost(maxCost);
                        ((SimpleVariable)e).getVariableDependencies().addAll(resultDependencies);               
                }
                
                return maxCost;
        }
        
        
        private int setCost(IfThenElse ite)
        {
                int maxCost = 0;
                int tempMaxCost = 0;
                
                tempMaxCost = setCost(ite.getCond());
                maxCost = maxCost < tempMaxCost ? tempMaxCost : maxCost;
                
                tempMaxCost = setCost(ite.getBodyTrue());
                maxCost = maxCost < tempMaxCost ? tempMaxCost : maxCost;
                
                tempMaxCost = setCost(ite.getBodyFalse());
                maxCost = maxCost < tempMaxCost ? tempMaxCost : maxCost;
                
                return maxCost;
        }
        
        
        public boolean getMonitor() { 
                return (nbMonitor>0); 
        } 
        
        
        public void modifyMonitor(boolean monitor) {
                if (monitor)
                        nbMonitor++;
                else
                        nbMonitor--; 
        }
        
        public boolean isEmpty() {
                if (top==null)
                        return true;
                if (top.name.isEmpty())
                        return true;
                return false;
        }

        public boolean fromXml(org.w3c.dom.Element el) {
                
                this.sourceMd5 = XMLUtils.getTextValue(el, "sourceMd5","");
                this.sourceCode = XMLUtils.getTextValue(el,"SourceCode","");
                this.top=new Function();
                

                NodeList nl = el.getElementsByTagName("Function");
                if(nl != null && nl.getLength() > 0) {
                        org.w3c.dom.Element e = (org.w3c.dom.Element)nl.item(0);
                        if (e!=null) {
                                this.top.fromXml(e);
                        }
                        else
                                this.top=null;
                }
                
        //      this.setSimulationCalcPrecision(XMLUtils.getIntValue(el,"Precision",0));
        //      this.setNumberOfSamples(XMLUtils.getIntValue(el,"NbSamples",5000));
        //      this.setInputFrequency(XMLUtils.getFloatValue(el,"InputFrequency",(float)100.0));
        //      this.setOutputFrequency(XMLUtils.getFloatValue(el,"OutputFrequency",(float)100.0));
        //      this.setSystemFrequency(XMLUtils.getFloatValue(el,"SystemFrequency",(float)100.0));
                return true;
        }

        public String getXmlTagName() {
                return "Struct";
        }
        
        public org.w3c.dom.Element toXml(Document dom) {
                org.w3c.dom.Element el;
                el=dom.createElement(getXmlTagName());
                el.appendChild(XMLUtils.createTextElement(dom,"sourceMd5",sourceMd5));
                el.appendChild(XMLUtils.createTextElement(dom, "SourceCode",sourceCode));
                if (top!=null)
                        el.appendChild(top.toXml(dom,false));
                /*int monindex=0;
                for(m2m.backend.structure.Element e : top.inputVars) {
                        if (e.getMonitor()) {
                                el.appendChild(XMLUtils.createTextElement(dom,"Monitor"+monindex,e.getName()));
                                monindex++;
                        }
                }
                for(m2m.backend.structure.Element e : top.outputVars) {
                        if (e.getMonitor()) {
                                el.appendChild(XMLUtils.createTextElement(dom,"Monitor"+monindex,e.getName()));
                                monindex++;
                        }
                }
                for(m2m.backend.structure.Element e : top.internalVars) {
                        if (e.getMonitor()) {
                                el.appendChild(XMLUtils.createTextElement(dom,"Monitor"+monindex,e.getName()));
                                monindex++;
                        }
                }
                */
                return el;
        }
        
        
        public Vector<Element> postParse(Function function) 
        {
                Vector<Element> elements = new Vector<Element>();
                Vector<Element> removeElements = new Vector<Element>();
                
                /* Add inputs variables to internals variables */
                if(function instanceof LoopFor) {
                        for(Element e : function.getInput())
                                function.addInternalVar(e);
                }
                
                elements = postParse(function.getBody());

                /* Remove all unused element in the function level */
                for(int i = 0; i < function.getInternalVars().size(); i++) {
                        if(!elements.contains(function.getInternalVars().elementAt(i)) && !function.inputVars.contains(function.getInternalVars().elementAt(i)))
                                removeElements.add(function.getInternalVars().elementAt(i));
                }
                
                function.getInternalVars().removeAll(removeElements);
                
                return elements;
        }
        
        
        public Vector<Element> postParse(Vector<Element> vector) 
        {
                Vector<Element> elements = new Vector<Element>();
                
                for(Element e : vector) {
                        if(e instanceof Operation) {
                                for(Element input : ((Operation)e).getInput()) {
                                        if(!elements.contains(input))
                                                elements.add(input);
                                }
                                for(Element output : ((Operation)e).getOutput()) {
                                        if(!elements.contains(output))
                                                elements.add(output);
                                }
                        }
                        else if (e instanceof IfThenElse) {
                                elements.addAll(postParse(((IfThenElse)e).getBodyFalse()));
                                elements.addAll(postParse(((IfThenElse)e).getBodyTrue()));
                                elements.addAll(postParse(((IfThenElse)e).getCond()));
                        }
                        else if(e instanceof Function){
                                postParse((Function)e);
                        }
                }
                
                return elements;
        }
}