torc::generic::Decompiler Class Reference

#include <Decompiler.hpp>

Inheritance diagram for torc::generic::Decompiler:

Collaboration diagram for torc::generic::Decompiler:

Public Member Functions
void	visit (Root &inroot) throw (Error)
void	visit (Design &inDesign) throw (Error)
void	visit (Library &inlibrary) throw (Error)
void	visit (Cell &incell) throw (Error)
void	visit (View &inview) throw (Error)
void	visit (ScalarPort &inscalarPort) throw (Error)
void	visit (VectorPort &invectorPort) throw (Error)
void	visit (VectorPortBit &inportBit) throw (Error)
void	visit (PortBundle &inportBundle) throw (Error)
void	visit (ScalarNet &inscalarNet) throw (Error)
void	visit (VectorNet &invectorNet) throw (Error)
void	visit (VectorNetBit &innetBit) throw (Error)
void	visit (NetBundle &innetBundle) throw (Error)
void	visit (SingleInstance &insingleInstance) throw (Error)
void	visit (InstanceArray &ininstanceArray) throw (Error)
void	visit (InstanceArrayMember &ininstanceArray) throw (Error)
void	visit (ScalarPortReference &inScalarPortRef) throw (Error)
void	visit (VectorPortReference &inVectorPortRef) throw (Error)
void	visit (VectorPortBitReference &inVectorPortBitRef) throw (Error)
void	visit (PortBundleReference &inPortBundleRef) throw (Error)
void	visit (SingleParameter &insingleParameter) throw (Error)
void	visit (ParameterArray &inparamArray) throw (Error)
void	visit (ParameterArrayElement &inParamArrayElement) throw (Error)
void	visit (Property &inProperty) throw (Error)
void	visit (PortList &inPortList) throw (Error)
void	visit (PortListAlias &inPortListAlias) throw (Error)
void	visit (Status &inStatus) throw (Error)
void	visit (Permutable &inPermutable) throw (Error)
void	visit (InterfaceJoinedInfo &inInterfaceJoinedInfo) throw (Error)
void	visit (SimulationInfo &simuInfo) throw (Error)
void	visit (Simulate &simulate) throw (Error)
void	visit (Apply &apply) throw (Error)
void	visit (LogicalResponse &logicalResponse) throw (Error)
void	visit (LogicValue &logicVal) throw (Error)
void	visit (LogicElement &logicElement) throw (Error)
void	visit (WaveValue &waveValue) throw (Error)
void	visit (Timing &timing) throw (Error)
void	visit (Event &event) throw (Error)
void	visit (ForbiddenEvent &forbiddenevent) throw (Error)
void	printValueType (const Value &value) throw (Error)
void	printValue (const Value &value) throw (Error)
void	printUnit (const Unit unit) throw (Error)
void	printDerivation (const Derivation derivation) throw (Error)
void	printArray (const std::vector< size_t > &outVector, size_t depth, std::vector< ParameterSharedPtr >::iterator &itStart, std::vector< ParameterSharedPtr >::iterator &itEnd) throw (Error)
void	printPortAttributes (const PortAttributesSharedPtr &inAttrib) throw (Error)
void	printNetAttributes (const NetAttributesSharedPtr &inAttrib) throw (Error)
void	printViewInterfaceAttributes (const InterfaceAttributesSharedPtr &inAttrib) throw (Error)
void	printLogicValueAttributes (const LogicValueAttributesSharedPtr &inAttrib) throw (Error)
void	printUserData (std::list< std::string > inElements) throw (Error)
void	printComments (std::vector< std::string > &inElements) throw (Error)
void	operator() () throw (Error)
void	decompile () throw (Error)
size_t	getIndentation () const
void	setIndentation (size_t inIndentation)
	Decompiler (const RootSharedPtr &inRoot, std::ostream &outStream=std::cout)
	Decompiler (const Decompiler &inSource)
	~Decompiler () throw ()
Decompiler &	operator= (const Decompiler &inSource)
virtual void	visit (_Tp &client)=0 throw (Error)

Private Attributes
RootSharedPtr	mRoot
std::ostream &	mOut
bool	mIsJoiningContext
bool	mIsPermutableContext
bool	mIsExternContext
bool	mParamAssignContext
bool	mIsPortInstanceContext
size_t	mIndentation
VisitorApplier< Decompiler >	mApplier

Detailed Description

This class generates an EDIF 2 0 0 file from an existing class hierarchy. It writes to a stream, so this can be used to write to any stream including string streams.

Definition at line 34 of file Decompiler.hpp.

Constructor & Destructor Documentation

torc::generic::Decompiler::Decompiler	(	const RootSharedPtr &	inRoot,
		std::ostream &	outStream = std::cout
	)

Definition at line 2349 of file Decompiler.cpp.

                                                                         : mRoot(inRoot),
    mOut(outStream), mIsJoiningContext(false), mIsPermutableContext(false),
    mIsExternContext(false), mParamAssignContext(false), mIsPortInstanceContext(false),
    mIndentation(0), mApplier(*this) {}

torc::generic::Decompiler::Decompiler

(

const Decompiler &

inSource

)

Definition at line 2356 of file Decompiler.cpp.

                                                 :
    mRoot(inSource.mRoot), mOut(inSource.mOut), mIsJoiningContext(inSource.mIsJoiningContext), mIsExternContext(
        inSource.mIsExternContext), mParamAssignContext(inSource.mParamAssignContext), mIsPortInstanceContext(
        inSource.mIsPortInstanceContext), mIndentation(inSource.mIndentation), mApplier(*this) {}

torc::generic::Decompiler::~Decompiler	(		)
throw	(
	)

Definition at line 2354 of file Decompiler.cpp.

{}

Member Function Documentation

void torc::generic::Decompiler::decompile	(		)
throw	(	Error
	)

Decompile the tree.

Parameters

[in]

root

Root of the OM tree.

Definition at line 2336 of file Decompiler.cpp.

                                         {
    try {
        mRoot->accept(*this);
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t torc::generic::Decompiler::getIndentation ( ) const

inline

Definition at line 173 of file Decompiler.hpp.

                                               {
    return mIndentation;
}

void torc::generic::Decompiler::operator()	(	void		)
throw	(	Error
	)

Convenience wrapper function to call decompile()

Definition at line 2322 of file Decompiler.cpp.

    {
    decompile();
}
catch(Error& e) {
    e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
    throw;
}

Here is the call graph for this function:

Decompiler & torc::generic::Decompiler::operator=

(

const Decompiler &

inSource

)

Definition at line 2361 of file Decompiler.cpp.

                                                            {
    if(this != &inSource) {
        mRoot = inSource.mRoot;
        mIsJoiningContext = inSource.mIsJoiningContext;
        mIsExternContext = inSource.mIsExternContext;
        mParamAssignContext = inSource.mParamAssignContext;
        mIsPortInstanceContext = inSource.mIsPortInstanceContext;
        mIndentation = inSource.mIndentation;
    }
    return *this;
}

void torc::generic::Decompiler::printArray	(	const std::vector< size_t > &	outVector,
		size_t	depth,
		std::vector< ParameterSharedPtr >::iterator &	itStart,
		std::vector< ParameterSharedPtr >::iterator &	itEnd
	)
throw	(	Error
	)

Definition at line 2007 of file Decompiler.cpp.

                                                                {
    Indenter indent(*this);

    size_t array_size = outVector.size();
    /*std::vector<size_t>::const_iterator it = outVector.begin();*/
    for(size_t i = 0; i < outVector.at(array_size - depth); i++) {
        if(depth == 1) {
            printValue((*itStart)->getValue());
            mOut << " ";
            if(itStart != itEnd) {
                ++itStart;
            }
        } else {
            mOut << std::endl << indent << "  ";
            printValueType((*itStart)->getValue());
            printArray(outVector, depth - 1, itStart, itEnd);
            mOut << ")";
        }
    }
}

void torc::generic::Decompiler::printComments	(	std::vector< std::string > &	inElements	)
throw	(	Error
	)

Definition at line 1813 of file Decompiler.cpp.

                                                                             {
    try {
        Indenter indent(*this);
        if(!inElements.empty()) {
            for(std::vector<std::string>::iterator it = inElements.begin(); it != inElements.end();
                ++it) {
                mOut << std::endl << indent << "(comment " << "\"" << trimLeadingSpaces(*it) << "\""
                    << ")";
            }
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::printDerivation	(	const Derivation	derivation	)
throw	(	Error
	)

Definition at line 1986 of file Decompiler.cpp.

                                                                          {
    mOut << "    (derivation ";
    switch(derivation) {
    case eDerivationCalculated: {
        mOut << "CALCULATED";
        break;
    }
    case eDerivationMeasured: {
        mOut << "MEASURED";
        break;
    }
    case eDerivationRequired: {
        mOut << "REQUIRED";
        break;
    }
    default: {
    }
    }
    mOut << ")" << std::endl;
}

void torc::generic::Decompiler::printLogicValueAttributes	(	const LogicValueAttributesSharedPtr &	inAttrib	)
throw	(	Error
	)

Definition at line 2205 of file Decompiler.cpp.

                  {

    if(!inAttrib)
        return;

    Indenter indent(*this);
    try {
        {
            if(inAttrib->getIsVoltageMapSet()) {
                Value::MiNoMax mnm = inAttrib->getVoltageMap();
                Value val(Value::eValueTypeMiNoMax, mnm);
                mOut << std::endl << indent << "(voltageMap ";
                printValue(val);
                mOut << ")";
            }
        }
        {
            if(inAttrib->getIsCurrentMapSet()) {
                Value::MiNoMax mnm = inAttrib->getCurrentMap();
                Value val(Value::eValueTypeMiNoMax, mnm);
                mOut << std::endl << indent << "(currentMap ";
                printValue(val);
                mOut << ")";
            }
        }
        {
            if(inAttrib->getIsBooleanMapSet()) {
                Value::Boolean boolean = inAttrib->getBooleanMap();
                Value val(Value::eValueTypeBoolean, boolean);
                mOut << std::endl << indent << "(booleanMap ";
                printValue(val);
                mOut << ")";
            }
        }
        {
            LogicValueSharedPtr logicVal = inAttrib->getWeakLogicValue();
            if(logicVal) {
                mOut << std::endl << indent << "(weak " << logicVal->getName() << ")";
            }
        }
        {
            LogicValueSharedPtr logicVal = inAttrib->getStrongLogicValue();
            if(logicVal) {
                mOut << std::endl << indent << "(strong " << logicVal->getName() << ")";
            }
        }
        {
            std::list<LogicValueSharedPtr> outLogicValues;
            inAttrib->getCompoundLogicValues(outLogicValues);
            if(!outLogicValues.empty()) {
                mOut << std::endl << indent << "(compound";
                std::list<LogicValueSharedPtr>::iterator it = outLogicValues.begin();
                for(; it != outLogicValues.end(); it++) {
                    mOut << " " << (*it)->getName();
                }
                mOut << ")";
            } else {
            }
        }
        {
            std::list<LogicValueSharedPtr> outLogicValues;
            inAttrib->getDominatedLogicValues(outLogicValues);
            if(!outLogicValues.empty()) {
                mOut << std::endl << indent << "(dominates";
                std::list<LogicValueSharedPtr>::iterator it = outLogicValues.begin();
                for(; it != outLogicValues.end(); it++) {
                    mOut << " " << (*it)->getName();
                }
                mOut << ")";
            } else {
            }
        }
        {
            std::list<LogicValueSharedPtr> outLogicValues;
            inAttrib->getResolvedLogicValues(outLogicValues);
            if(!outLogicValues.empty()) {
                mOut << std::endl << indent << "(resolves";
                std::list<LogicValueSharedPtr>::iterator it = outLogicValues.begin();
                for(; it != outLogicValues.end(); it++) {
                    mOut << " " << (*it)->getName();
                }
                mOut << ")";
            } else {
            }
        }
        {
            bool isolated = inAttrib->getIsIsolated();
            if(isolated) {
                mOut << std::endl << indent << "(isolated)";
            }
        }
        {
            typedef LogicValueAttributes::LogicMap LogicMap;
            std::list<LogicMap*> outLogicMaps;
            inAttrib->getLogicMaps(outLogicMaps);
            if(!outLogicMaps.empty()) {
                std::list<LogicMap*>::iterator it = outLogicMaps.begin();

                for(; it != outLogicMaps.end(); it++) {
                    if((*it)->mLogicMapType == LogicMap::eLogicMapTypeInput) {
                        mOut << std::endl << indent << "(logicMapInput ";
                    } else {
                        mOut << std::endl << indent << "(logicMapOutput ";
                    }
                    mOut << "(logicRef " << (*it)->mLogicRef;
                    mOut << " (libraryRef " << (*it)->mLibraryRef << ")";
                    mOut << "))";
                }
            } else {
            }
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::printNetAttributes	(	const NetAttributesSharedPtr &	inAttrib	)
throw	(	Error
	)

Definition at line 2131 of file Decompiler.cpp.

                                                                                        {
    if(!inAttrib)
        return;

    Indenter indent(*this);
    try {
        (*this).setIndentation((*this).getIndentation() - 2);
        if(inAttrib->getIsCriticalitySet()) {
            int32_t criticality = inAttrib->getCriticality();
            mOut << std::endl << indent << "(criticality " << criticality << ")";
        }
        if(inAttrib->getIsNetDelaySet()) {
            NetDelay netDelay = inAttrib->getNetDelay();
            mOut << std::endl << indent << "(netDelay " << std::endl;
            mOut << indent;
            printDerivation(netDelay.getDerivation());

            mOut << indent << "    (delay ";
            Value::MiNoMax mnm = netDelay.getDelay();
            Value val(Value::eValueTypeMiNoMax, mnm);
            printValue(val);
            mOut << ")";

            //Print transition/becomes
            if(NULL != netDelay.getTransition()) {
                netDelay.getTransition()->accept(*this);
            }
            mOut << std::endl << indent << ")";
        }
        (*this).setIndentation((*this).getIndentation() + 2);
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::printPortAttributes	(	const PortAttributesSharedPtr &	inAttrib	)
throw	(	Error
	)

Definition at line 2030 of file Decompiler.cpp.

                                                                                          {
    if(!inAttrib)
        return;

    Indenter indent(*this);
    try {
        {
            Value unused = inAttrib->getUnused();
            if(unused.getIsSet()) {
                mOut << std::endl << indent << "(unused)";
            }
        }
        {
            Value designator = inAttrib->getDesignator();
            if(designator.getIsSet()) {
                mOut << std::endl << indent << "(designator " << "\""
                    << designator.get<Value::String>() << "\"" << ")";
            }
        }
        {
            Value val = inAttrib->getDcFaninLoad();
            if(val.getIsSet()) {
                mOut << std::endl << indent << "(dcFaninLoad ";
                printValue(val);
                mOut << ")";
            }
        }
        {
            Value val = inAttrib->getDcFanoutLoad();
            if(val.getIsSet()) {
                mOut << std::endl << indent << "(dcFanoutLoad ";
                printValue(val);
                mOut << ")";
            }
        }
        {
            Value val = inAttrib->getDcMaxFanin();
            if(val.getIsSet()) {
                mOut << std::endl << indent << "(dcMaxFanin ";
                printValue(val);
                mOut << ")";
            }
        }
        {
            Value val = inAttrib->getDcMaxFanout();
            if(val.getIsSet()) {
                mOut << std::endl << indent << "(dcMaxFanout ";
                printValue(val);
                mOut << ")";
            }
        }
        {
            Value val = inAttrib->getAcLoad();
            if(val.getIsSet()) {
                mOut << std::endl << indent << "(acLoad ";
                printValue(val);
                mOut << ")";
            }
        }
        if(inAttrib->getIsPortDelaySet()) {
            PortDelay delay = inAttrib->getPortDelay();
            mOut << std::endl << indent << "(portDelay " << std::endl;
            mOut << indent;
            printDerivation(delay.getDerivation());
            switch(delay.getType()) {
            case PortDelay::eTypeDelay: {
                mOut << indent << "    (delay ";
                Value::MiNoMax mnm = delay.getDelay();
                Value val(Value::eValueTypeMiNoMax, mnm);
                printValue(val);
                mOut << ")";
                break;
            }
            case PortDelay::eTypeLoadDelay: {
                mOut << indent << "    (loadDelay ";
                {
                    Value::MiNoMax mnm = delay.getDelay();
                    Value val(Value::eValueTypeMiNoMax, mnm);
                    printValue(val);
                }
                {
                    Value::MiNoMax mnm = delay.getAcLoad();
                    Value val(Value::eValueTypeMiNoMax, mnm);
                    printValue(val);
                }
                mOut << ")";
                break;
            }
            }
            //Print transition/becomes
            if(NULL != delay.getTransition()) {
                delay.getTransition()->accept(*this);
            }
            mOut << ")";
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::printUnit	(	const Unit	unit	)
throw	(	Error
	)

Definition at line 1915 of file Decompiler.cpp.

                                                        {
    switch(unit) {
    case eUnitAngle: {
        mOut << " (unit ANGLE )";
        break;
    }
    case eUnitCapacitance: {
        mOut << " (unit CAPACITANCE )";
        break;
    }
    case eUnitConductance: {
        mOut << " (unit CONDUCTANCE )";
        break;
    }
    case eUnitCharge: {
        mOut << " (unit CHARGE )";
        break;
    }
    case eUnitCurrent: {
        mOut << " (unit CURRENT )";
        break;
    }
    case eUnitDistance: {
        mOut << " (unit DISTANCE )";
        break;
    }
    case eUnitEnergy: {
        mOut << " (unit ENERGY )";
        break;
    }
    case eUnitFlux: {
        mOut << " (unit FLUX )";
        break;
    }
    case eUnitFrequency: {
        mOut << " (unit FREQUENCY )";
        break;
    }
    case eUnitInductance: {
        mOut << " (unit INDUCTANCE )";
        break;
    }
    case eUnitMass: {
        mOut << " (unit MASS )";
        break;
    }
    case eUnitPower: {
        mOut << " (unit POWER )";
        break;
    }
    case eUnitResistance: {
        mOut << " (unit RESISTANCE )";
        break;
    }
    case eUnitTemperature: {
        mOut << " (unit TEMPERATURE )";
        break;
    }
    case eUnitTime: {
        mOut << " (unit TIME )";
        break;
    }
    case eUnitVoltage: {
        mOut << " (unit VOLTAGE )";
        break;
    }
    default: {
    }
    }
}

void torc::generic::Decompiler::printUserData	(	std::list< std::string >	inElements	)
throw	(	Error
	)

Definition at line 1797 of file Decompiler.cpp.

                                                                          {
    try {
        Indenter indent(*this);
        if(!inElements.empty()) {
            for(std::list<std::string>::iterator it = inElements.begin(); it != inElements.end();
                ++it) {
                mOut << std::endl << indent << "(userData " << trimLeadingSpaces(*it);
            }
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::printValue	(	const Value &	value	)
throw	(	Error
	)

Definition at line 1859 of file Decompiler.cpp.

                                                            {
    if(!value.getIsSet()) {
        return;
    }
    switch(value.getType()) {
    case Value::eValueTypeBoolean: {
        mOut << ((value.get<Value::Boolean>()) ? "(true)" : "(false)");
        break;
    }
    case Value::eValueTypeInteger: {
        mOut << value.get<Value::Integer>();
        break;
    }
    case Value::eValueTypeMiNoMax: {
        Value::MiNoMax mnm = value.get<Value::MiNoMax>();
        mOut << "(mnm ";
        if(!mnm.getMinUndefined()) {
            Value val(Value::eValueTypeNumber, mnm.getMin());
            printValue(val);
            mOut << " ";
        } else {
            mOut << "(undefined) ";
        }

        Value val(Value::eValueTypeNumber, mnm.getNominal());
        printValue(val);
        mOut << " ";

        if(!mnm.getMinUndefined()) {
            Value val(Value::eValueTypeNumber, mnm.getMax());
            printValue(val);
        } else {
            mOut << "(undefined)";
        }
        mOut << ")";
        break;
    }
    case Value::eValueTypeNumber: {
        Value::Number num = value.get<Value::Number>();
        mOut << "(e " << num.getMantissa() << " " << num.getExponent() << ")";
        break;
    }
    case Value::eValueTypePoint: {
        Value::Point pt = value.get<Value::Point>();
        mOut << "(pt " << pt.getX() << " " << pt.getY() << ")";
        break;
    }
    case Value::eValueTypeString: {
        mOut << "\"" << value.get<Value::String>() << "\"";
        break;
    }
    default: {
    }
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::printValueType	(	const Value &	value	)
throw	(	Error
	)

Definition at line 1828 of file Decompiler.cpp.

                                                                {
    switch(value.getType()) {
    case Value::eValueTypeBoolean: {
        mOut << " (boolean ";
        break;
    }
    case Value::eValueTypeInteger: {
        mOut << " (integer ";
        break;
    }
    case Value::eValueTypeMiNoMax: {
        mOut << " (minomax ";
        break;
    }
    case Value::eValueTypeNumber: {
        mOut << " (number ";
        break;
    }
    case Value::eValueTypePoint: {
        mOut << " (point ";
        break;
    }
    case Value::eValueTypeString: {
        mOut << " (string ";
        break;
    }
    default: {
    }
    }
}

void torc::generic::Decompiler::printViewInterfaceAttributes	(	const InterfaceAttributesSharedPtr &	inAttrib	)
throw	(	Error
	)

Definition at line 2167 of file Decompiler.cpp.

                  {
    if(!inAttrib)
        return;

    Indenter indent(*this);
    try {
        if(!inAttrib->getDesignator().empty()) {
            mOut << std::endl << indent << "  (designator " << "\"" << inAttrib->getDesignator()
                << "\"" << ")";
        }

        if(NULL != inAttrib->getSimulate()) {
            (*this).setIndentation((*this).getIndentation() - 4);
            inAttrib->getSimulate()->accept(*this);
            (*this).setIndentation((*this).getIndentation() + 4);
        }

        if(NULL != inAttrib->getTiming()) {
            (*this).setIndentation((*this).getIndentation() - 4);
            inAttrib->getTiming()->accept(*this);
            (*this).setIndentation((*this).getIndentation() + 4);
        }

        //Print Comments
        std::vector < std::string > comments = inAttrib->getComments();
        printComments(comments);

        std::list < std::string > userDatas;
        inAttrib->getUserData(userDatas);
        printUserData(userDatas);
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::setIndentation

(

size_t

inIndentation

)

Definition at line 2345 of file Decompiler.cpp.

                                                    {
    mIndentation = inIndentation;
}

void torc::generic::Decompiler::visit	(	Root &	inroot	)
throw	(	Error
	)

Definition at line 178 of file Decompiler.cpp.

                                               {
    try {
        CircularDependencyResolver resolver;
        resolver.resolve(root.getSharedThis());
        if(!root.getOriginalName().empty()) {
            mOut << "(edif (rename " << root.getName() << " " << "\"" << root.getOriginalName()
                << "\"" << ")" << std::endl;
        } else {
            mOut << "(edif " << root.getName() << std::endl;
        }
        mOut << "  (edifVersion " << (int32_t) root.getVersion().mFirst << " "
            << (int32_t) root.getVersion().mSecond << " " << (int32_t) root.getVersion().mThird
            << ")" << std::endl;
        mOut << "  (edifLevel " << root.getLevel() << ")" << std::endl;
        mOut << "  (keywordMap (keywordLevel  0" << "))";

        //Print Comments
        std::vector < std::string > comments = root.getComments();
        printComments(comments);

        root.applyOnAllStatuses(mApplier);

        mIsExternContext = true;
        std::for_each(resolver.mExterns.begin(), resolver.mExterns.end(), mApplier);
        mIsExternContext = false;

        std::for_each(resolver.mConcreteLibs.begin(), resolver.mConcreteLibs.end(), mApplier);
        root.applyOnAllDesigns(mApplier);

        std::list < std::string > elements;
        root.getUserData(elements);
        printUserData(elements);

        mOut << std::endl << ")" << std::endl;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	Design &	inDesign	)
throw	(	Error
	)

Definition at line 219 of file Decompiler.cpp.

                                                   {
    try {
        Indenter indent(*this);
        if(!design.getOriginalName().empty()) {
            mOut << std::endl << indent << "(design " << "(rename " << design.getName() << " "
                << "\"" << design.getOriginalName() << "\"" << ")";
        } else {
            mOut << std::endl << indent << "(design " << design.getName();
        }
        mOut << std::endl << indent << "  (cellRef " << design.getCellRefName() << " (libraryRef "
            << design.getLibraryRefName() << "))";

        //Print Comments
        std::vector < std::string > comments = design.getComments();
        printComments(comments);

        design.applyOnAllStatuses(mApplier);
        design.applyOnAllProperties(mApplier);

        std::list < std::string > elements;
        design.getUserData(elements);
        printUserData(elements);

        mOut << std::endl << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	Library &	inlibrary	)
throw	(	Error
	)

Definition at line 250 of file Decompiler.cpp.

                                                     {
    try {
        Indenter indent(*this);
        if(mIsExternContext || library.getIsExtern()) {
            if(!library.getOriginalName().empty()) {
                mOut << std::endl << indent << "(external ";
                mOut << std::endl << indent << "  (rename " << library.getName() << " " << "\""
                    << library.getOriginalName() << "\"" << ")";
            } else {
                mOut << std::endl << indent << "(external " << library.getName();
            }
        } else {
            if(!library.getOriginalName().empty()) {
                mOut << std::endl << indent << "(library ";
                mOut << std::endl << indent << "  (rename " << library.getName() << " " << "\""
                    << library.getOriginalName() << "\"" << ")";
            } else {
                mOut << std::endl << indent << "(library " << library.getName();
            }
        }
        mOut << std::endl << indent << "  (ediflevel " << library.getLevel() << ")"
            << " (technology (numberDefinition";

        std::map<Unit, ScaleFactor> outScaleFactors;
        outScaleFactors = library.getScaleFactors();
        std::map<Unit, ScaleFactor>::iterator it = outScaleFactors.begin();
        for(; it != outScaleFactors.end(); ++it) {
            Unit unit = (*it).first;
            ScaleFactor scale = (*it).second;
            mOut << std::endl << indent << "  (scale ";
            printValue(Value(Value::eValueTypeNumber, scale.getSiValue()));
            printValue(Value(Value::eValueTypeNumber, scale.getEdifValue()));
            printUnit(unit);
            mOut << ")";
        }
        mOut << ")";

        SimulationInfoSharedPtr simuInfo = library.getSimulationInfo();
        if(simuInfo) {
            simuInfo->accept(*this);
        }
        mOut << ")";

        //Print Comments
        std::vector < std::string > comments = library.getComments();
        printComments(comments);

        library.applyOnAllStatuses(mApplier);

        std::list < std::string > elements;
        library.getUserData(elements);
        printUserData(elements);

        library.applyOnAllCells(mApplier);
        mOut << std::endl << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	Cell &	incell	)
throw	(	Error
	)

Definition at line 312 of file Decompiler.cpp.

                                               {
    try {
        Indenter indent(*this);
        std::string cellType;
        switch(cell.getType()) {
        case Cell::eTypeTie: {
            cellType = "TIE";
            break;
        }
        case Cell::eTypeRipper: {
            cellType = "RIPPER";
            break;
        }
        case Cell::eTypeGeneric: {
            cellType = "GENERIC";
            break;
        }
        default: {
        }
        }
        if(!cell.getOriginalName().empty()) {
            mOut << std::endl << indent << "(cell ";
            mOut << std::endl << indent << "  (rename " << cell.getName() << " " << "\""
                << cell.getOriginalName() << "\"" << ")";
        } else {
            mOut << std::endl << indent << "(cell " << cell.getName();
        }
        mOut << std::endl << indent << "  (cellType " << cellType << ")";

        //Print Comments
        std::vector < std::string > comments = cell.getComments();
        printComments(comments);

        cell.applyOnAllStatuses(mApplier);

        std::list < std::string > elements;
        cell.getUserData(elements);
        printUserData(elements);

        cell.applyOnAllViews(mApplier);
        cell.applyOnAllProperties(mApplier);
        mOut << std::endl << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	View &	inview	)
throw	(	Error
	)

Definition at line 361 of file Decompiler.cpp.

                                               {
    try {
        Indenter indent(*this);
        std::string viewType;
        switch(view.getType()) {
        case View::eTypeMaskLayout: {
            viewType = "MASKLAYOUT";
            break;
        }
        case View::eTypePCBLayout: {
            viewType = "PCBLAYOUT";
            break;
        }
        case View::eTypeNetlist: {
            viewType = "NETLIST";
            break;
        }
        case View::eTypeSchematic: {
            viewType = "SCHEMATIC";
            break;
        }
        case View::eTypeSymbolic: {
            viewType = "SYMBOLIC";
            break;
        }
        case View::eTypeBehavior: {
            viewType = "BEHAVIOR";
            break;
        }
        case View::eTypeLogicModel: {
            viewType = "LOGICMODEL";
            break;
        }
        case View::eTypeDocument: {
            viewType = "DOCUMENT";
            break;
        }
        case View::eTypeGraphic: {
            viewType = "GRAPHIC";
            break;
        }
        case View::eTypeStranger: {
            viewType = "STRANGER";
            break;
        }
        }
        if(!view.getOriginalName().empty()) {
            mOut << std::endl << indent << "(view ";
            mOut << std::endl << indent << "  (rename " << view.getName() << " " << "\""
                << view.getOriginalName() << "\"" << ")";
        } else {
            mOut << std::endl << indent << "(view " << view.getName();
        }
        mOut << std::endl << indent << "  (viewType " << viewType << ")";

        if(View::eTypeNetlist != view.getType()) {
            mOut << view.getNonNetlistViewData();
            return;
        }

        mOut << std::endl << indent << "  (interface ";
        mIsJoiningContext = false;
        view.applyOnAllPorts(mApplier);
        printViewInterfaceAttributes(view.getInterfaceAttributes());
        typedef std::map<std::string, ParameterSharedPtr> Params;
        ParameterMapSharedPtr params = view.getParameters();
        ParameterContext context = view.getParameterContext();
        Params paramMap;
        params->getAllParameters(context, paramMap);
        for(Params::iterator it = paramMap.begin(); it != paramMap.end(); it++) {
            (*it).second->accept(*this);
        }
        mIsJoiningContext = true;
        view.applyOnAllPermutables(mApplier);
        view.applyOnAllInterfaceJoinedInfos(mApplier);
        mOut << std::endl << indent << "  )";
        view.applyOnAllProperties(mApplier);

        //Print Comments
        std::vector < std::string > comments = view.getComments();
        printComments(comments);

        view.applyOnAllStatuses(mApplier);

        std::list < std::string > elements;
        view.getUserData(elements);
        printUserData(elements);

        if(!mIsExternContext) {

            std::vector<InstanceSharedPtr> instVec;
            view.getInstances(instVec);

            std::vector<NetSharedPtr> netVec;
            view.getNets(netVec);

            if(!instVec.empty() || !netVec.empty()) {
                mOut << std::endl << indent << "  (contents ";
                //Print all instances of the current view
                mIsJoiningContext = false;
                view.applyOnAllInstances(mApplier);

                if(NULL != view.getSimulate()) {
                    view.getSimulate()->accept(*this);
                }

                //Print all net info
                mIsJoiningContext = true;
                view.applyOnAllNets(mApplier);

                if(NULL != view.getTiming()) {
                    view.getTiming()->accept(*this);
                }

                mOut << std::endl << indent << "  )";
            }
        }
        mOut << std::endl << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	ScalarPort &	inscalarPort	)
throw	(	Error
	)

Definition at line 486 of file Decompiler.cpp.

                                                     {
    try {
        Indenter indent(*this);
        if(!mIsJoiningContext) {
            if(!port.getOriginalName().empty()) {
                mOut << std::endl << indent << "(port ";
                mOut << std::endl << indent << "  (rename " << port.getName() << " " << "\""
                    << port.getOriginalName() << "\"" << ")";
            } else {
                mOut << std::endl << indent << "(port " << port.getName();
            }
            switch(port.getDirection()) {
            case ePortDirectionIn: {
                mOut << std::endl << indent << "  (direction INPUT)";
                break;
            }
            case ePortDirectionOut: {
                mOut << std::endl << indent << "  (direction OUTPUT)";
                break;
            }
            case ePortDirectionInOut: {
                mOut << std::endl << indent << "  (direction INOUT)";
                break;
            }
            default: {
            }
            }
            printPortAttributes(port.getAttributes());

            //Print Comments
            std::vector < std::string > comments = port.getComments();
            printComments(comments);

            std::list < std::string > elements;
            port.getUserData(elements);
            printUserData(elements);

            port.applyOnAllProperties(mApplier);
            mOut << std::endl << indent << ")";
        } else {
            mOut << std::endl << indent << "(portRef " << port.getName();
            PortSharedPtr parentCol = port.getParentCollection();
            if(parentCol) {
                parentCol->accept(*this);
            }
            mOut << ")";
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	VectorPort &	invectorPort	)
throw	(	Error
	)

Definition at line 563 of file Decompiler.cpp.

                                                     {
    try {
        Indenter indent(*this);
        if(mIsJoiningContext) {
            mOut << std::endl << indent << "(portRef " << port.getName();
            PortSharedPtr parentCol = port.getParentCollection();
            if(parentCol) {
                parentCol->accept(*this);
            }
            mOut << ")";
        } else {
            if(!port.getOriginalName().empty()) {
                mOut << std::endl << indent << "(port ";
                mOut << std::endl << indent << "  (array (rename " << port.getName() << " " << "\""
                    << port.getOriginalName() << "\"" << ")" << " ";
            } else {
                mOut << std::endl << indent << "(port (array " << port.getName() << " ";
            }
            std::vector < size_t > limits;
            port.getLimits(limits);
            copy(limits.begin(), limits.end(), std::ostream_iterator < size_t > (mOut, " "));
            mOut << ")";
            switch(port.getDirection()) {
            case ePortDirectionIn: {
                mOut << std::endl << indent << "  (direction INPUT)";
                break;
            }
            case ePortDirectionOut: {
                mOut << std::endl << indent << "  (direction OUTPUT)";
                break;
            }
            case ePortDirectionInOut: {
                mOut << std::endl << indent << "  (direction INOUT)";
                break;
            }
            default: {
            }

            }
            printPortAttributes(port.getAttributes());

            //Print Comments
            std::vector < std::string > comments = port.getComments();
            printComments(comments);

            std::list < std::string > elements;
            port.getUserData(elements);
            printUserData(elements);

            port.applyOnAllProperties(mApplier);
            mOut << std::endl << indent << ")";
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	VectorPortBit &	inportBit	)
throw	(	Error
	)

Definition at line 645 of file Decompiler.cpp.

                                                       {
    try {
        Indenter indent(*this);
        if(mIsJoiningContext) {
            PortSharedPtr parent = bit.getParentCollection();
            mOut << std::endl << indent << "(portRef (member " << parent->getName() << " ";
            copy(bit.getIndices().begin(), bit.getIndices().end(),
                std::ostream_iterator < size_t > (mOut, " "));
            mOut << ")";
            PortSharedPtr parentCol = parent->getParentCollection();
            if(parentCol) {
                parentCol->accept(*this);
            }
            mOut << ")";
            bit.applyOnAllProperties(mApplier);
        } else {
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	PortBundle &	inportBundle	)
throw	(	Error
	)

Definition at line 696 of file Decompiler.cpp.

                                                     {
    try {
        Indenter indent(*this);
        if(mIsJoiningContext) {
            if(mIsPermutableContext) {
                mOut << std::endl << indent << "(portRef " << port.getName();
            } else {
                mOut << " (portRef " << port.getName();
            }
            PortSharedPtr parentCol = port.getParentCollection();
            if(parentCol) {
                parentCol->accept(*this);
            }
            mOut << ")";
        } else {
            if(!port.getOriginalName().empty()) {
                mOut << std::endl << indent << "(portBundle ";
                mOut << std::endl << indent << "  (rename " << port.getName() << " " << "\""
                    << port.getOriginalName() << "\"" << ")";
            } else {
                mOut << std::endl << indent << "(portBundle " << port.getName();
            }
            {
                Indenter subIndent(*this);
                mOut << std::endl << subIndent << "(listOfPorts ";
                port.applyOnAllChildren(mApplier);
                mOut << std::endl << subIndent << ")";
            }

            //Print Comments
            std::vector < std::string > comments = port.getComments();
            printComments(comments);

            std::list < std::string > elements;
            port.getUserData(elements);
            printUserData(elements);

            mOut << std::endl << indent << ")";
        }
        port.applyOnAllProperties(mApplier);
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	ScalarNet &	inscalarNet	)
throw	(	Error
	)

Definition at line 828 of file Decompiler.cpp.

                                                   {
    try {
        Indenter indent(*this);
        if(mIsJoiningContext) {
            if(!net.getOriginalName().empty()) {
                mOut << std::endl << indent << "(net ";
                mOut << std::endl << indent << "  (rename " << net.getName() << " " << "\""
                    << net.getOriginalName() << "\"" << ")";
            } else {
                mOut << std::endl << indent << "(net " << net.getName();
            }

            mOut << std::endl << indent << "  (joined ";
            mIsJoiningContext = true;
            net.applyOnAllConnectedPorts(mApplier);
            net.applyOnAllConnectedPortRefs(mApplier);
            net.applyOnAllConnectedPortLists(mApplier);
            mOut << std::endl << indent << "  )";

            printNetAttributes(net.getAttributes());

            //Print Comments
            std::vector < std::string > comments = net.getComments();
            printComments(comments);

            std::list < std::string > elements;
            net.getUserData(elements);
            printUserData(elements);

            net.applyOnAllSubnets(mApplier);
            net.applyOnAllProperties(mApplier);
            mOut << std::endl << indent << ")";
        } else {
            mOut << std::endl << indent << "(netRef " << net.getName();
            NetSharedPtr parentCol = net.getParentCollection();
            if(parentCol) {
                parentCol->accept(*this);
            }
            mOut << ")";
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	VectorNet &	invectorNet	)
throw	(	Error
	)

Definition at line 920 of file Decompiler.cpp.

                                                   {
    try {
        Indenter indent(*this);
        if(mIsJoiningContext) {
            if(!net.getOriginalName().empty()) {
                mOut << std::endl << indent << "(net ";
                mOut << std::endl << indent << "  (array (rename " << net.getName() << " " << "\""
                    << net.getOriginalName() << "\"" << ")" << " ";
            } else {
                mOut << std::endl << indent << "(net (array " << net.getName() << " ";
            }
            std::vector < size_t > limits;
            net.getLimits(limits);
            copy(limits.begin(), limits.end(), std::ostream_iterator < size_t > (mOut, " "));
            mOut << ")";

            mOut << std::endl << indent << "  (joined";
            mIsJoiningContext = true;
            net.applyOnAllConnectedPorts(mApplier);
            net.applyOnAllConnectedPortRefs(mApplier);
            net.applyOnAllConnectedPortLists(mApplier);
            mOut << std::endl << indent << "  )";

            printNetAttributes(net.getAttributes());

            //Print Comments
            std::vector < std::string > comments = net.getComments();
            printComments(comments);

            std::list < std::string > elements;
            net.getUserData(elements);
            printUserData(elements);

            net.applyOnAllSubnets(mApplier);
            net.applyOnAllProperties(mApplier);
            mOut << std::endl << indent << ")";
        } else {
            mOut << std::endl << indent << "(netRef " << net.getName();
            NetSharedPtr parentCol = net.getParentCollection();
            if(parentCol) {
                parentCol->accept(*this);
            }
            mOut << ")";
        }

    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	VectorNetBit &	innetBit	)
throw	(	Error
	)

Definition at line 972 of file Decompiler.cpp.

                                                      {
    try {
        //mIsJoiningContext = true;
#if 0    
        mOut << "                VectorNetBit name : " << net.getName() << std::endl;
        mOut << "                  Size            : " << net.getSize() << std::endl;
        net.applyOnAllSubnets(mApplier);
        net.applyOnAllConnectedPorts(mApplier);
        net.applyOnAllConnectedPortRefs(mApplier);
        net.applyOnAllProperties(mApplier);
#endif
        //TBD
        //mIsJoiningContext = false;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	NetBundle &	innetBundle	)
throw	(	Error
	)

Definition at line 875 of file Decompiler.cpp.

                                                   {
    try {
        Indenter indent(*this);
        if(mIsJoiningContext) {
            if(!net.getOriginalName().empty()) {
                mOut << std::endl << indent << "(netbundle ";
                mOut << std::endl << indent << "  (rename " << net.getName() << " " << "\""
                    << net.getOriginalName() << "\"" << ")";
            } else {
                mOut << std::endl << indent << "(netbundle " << net.getName();
            }
            mOut << std::endl << indent << "  (listOfNets ";
            net.applyOnAllSubnets(mApplier);
            net.applyOnAllChildren(mApplier);
            net.applyOnAllConnectedPorts(mApplier);
            net.applyOnAllConnectedPortRefs(mApplier);
            net.applyOnAllConnectedPortLists(mApplier);

            mOut << std::endl << indent << "  )";

            //Print Comments
            std::vector < std::string > comments = net.getComments();
            printComments(comments);

            std::list < std::string > elements;
            net.getUserData(elements);
            printUserData(elements);

            net.applyOnAllProperties(mApplier);
            mOut << std::endl << indent << ")";
        } else {
            mOut << std::endl << indent << "(netRef " << net.getName();
            NetSharedPtr parentCol = net.getParentCollection();
            if(parentCol) {
                parentCol->accept(*this);
            }
            mOut << ")";
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	SingleInstance &	insingleInstance	)
throw	(	Error
	)

Definition at line 761 of file Decompiler.cpp.

                                                             {
    try {

        if(mIsJoiningContext) {
            mOut << " (instanceRef " << instance.getName() << ")";
        } else {
            Indenter indent(*this);
            if(!instance.getOriginalName().empty()) {
                mOut << std::endl << indent << "(instance ";
                mOut << std::endl << indent << "  (rename " << instance.getName() << " " << "\""
                    << instance.getOriginalName() << "\"" << ")";
            } else {
                mOut << std::endl << indent << "(instance " << instance.getName();
            }
            mOut << std::endl << indent << "  (viewRef " << instance.getMaster()->getName()
                << " (cellRef " << instance.getMaster()->getParent()->getName() << " (libraryRef "
                << instance.getMaster()->getParent()->getParent()->getName() << ")))";

            if(!instance.getDesignator().empty()) {
                mOut << std::endl << indent << "  (designator " << "\"" << instance.getDesignator()
                    << "\"" << ")";
            }

            if(NULL != instance.getTiming()) {
                instance.getTiming()->accept(*this);
            }

            //Print Comments
            std::vector < std::string > comments = instance.getComments();
            printComments(comments);

            std::list < std::string > elements;
            instance.getUserData(elements);
            printUserData(elements);

            mParamAssignContext = true;
            typedef std::map<std::string, ParameterSharedPtr> Params;
            ParameterMapSharedPtr params = instance.getParameters();
            ParameterContext context = instance.getParameterContext();
            params->applyOnOverriddenParameters(context, mApplier);
            mParamAssignContext = false;
            instance.applyOnAllProperties(mApplier);
            std::vector<PortReferenceSharedPtr> portRefs;
            instance.getPortReferences(portRefs);
            for(std::vector<PortReferenceSharedPtr>::iterator portRef = portRefs.begin();
                portRef != portRefs.end(); ++portRef) {
                PortAttributesSharedPtr attribs = (*portRef)->getAttributes();
                if(attribs) {
                    mOut << std::endl << indent << "  (portInstance ";
                    mIsPortInstanceContext = true;
                    mIsJoiningContext = true;
                    (*portRef)->accept(*this);
                    mIsJoiningContext = false;
                    mIsPortInstanceContext = false;
                    printPortAttributes(attribs);
                    mOut << std::endl << indent << "  )";
                }
            }
            mOut << std::endl << indent << ")";
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	InstanceArray &	ininstanceArray	)
throw	(	Error
	)

Definition at line 992 of file Decompiler.cpp.

                                                                 {
    try {
        Indenter indent(*this);
        if(!instanceArray.getOriginalName().empty()) {
            mOut << std::endl << indent << "(instance ";
            mOut << std::endl << indent << "  (array (rename " << instanceArray.getName() << " "
                << "\"" << instanceArray.getOriginalName() << "\"" << ")" << " ";
        } else {
            mOut << std::endl << indent << "(instance (array " << instanceArray.getName() << " ";
        }
        std::vector < size_t > limits;
        instanceArray.getLimits(limits);
        copy(limits.begin(), limits.end(), std::ostream_iterator < size_t > (mOut, " "));
        mOut << ")";
        mOut << std::endl << indent << "  (viewRef " << instanceArray.getMaster()->getName()
            << " (cellRef " << instanceArray.getMaster()->getParent()->getName() << " (libraryRef "
            << instanceArray.getMaster()->getParent()->getParent()->getName() << ")))";

        if(!instanceArray.getDesignator().empty()) {
            mOut << std::endl << indent << "  (designator " << "\"" << instanceArray.getDesignator()
                << "\"" << ")";
        }

        //Print Comments
        std::vector < std::string > comments = instanceArray.getComments();
        printComments(comments);

        std::list < std::string > elements;
        instanceArray.getUserData(elements);
        printUserData(elements);

        mParamAssignContext = true;
        typedef std::map<std::string, ParameterSharedPtr> Params;
        ParameterMapSharedPtr params = instanceArray.getParameters();
        ParameterContext context = instanceArray.getParameterContext();
        params->applyOnOverriddenParameters(context, mApplier);
        mParamAssignContext = false;
        instanceArray.applyOnAllProperties(mApplier);
        mOut << std::endl << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	InstanceArrayMember &	ininstanceArray	)
throw	(	Error
	)

Definition at line 1038 of file Decompiler.cpp.

                                                                  {
    try {
        if(mIsJoiningContext) {
            mOut << "(instanceRef (member " << instance.getParentCollection()->getName() << " ";
            copy(instance.getIndices().begin(), instance.getIndices().end(),
                std::ostream_iterator < size_t > (mOut, " "));
            mOut << "))";
        } else {
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	ScalarPortReference &	inScalarPortRef	)
throw	(	Error
	)

Definition at line 540 of file Decompiler.cpp.

                                                                 {
    try {
        Indenter indent(*this);
        if(mIsJoiningContext) {
            mOut << std::endl << indent << "(portRef " << portRef.getName();
            PortReferenceSharedPtr parentCol = portRef.getParentCollection();
            if(parentCol) {
                parentCol->accept(*this);
            } else {
                if(!mIsPortInstanceContext) {
                    portRef.getParent()->accept(*this);
                }
            }
            mOut << ")";
        } else {
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	VectorPortReference &	inVectorPortRef	)
throw	(	Error
	)

Definition at line 622 of file Decompiler.cpp.

                                                                 {
    try {
        Indenter indent(*this);
        if(mIsJoiningContext) {
            mOut << std::endl << indent << "(portRef " << portRef.getName() << " ";
            PortReferenceSharedPtr parentCol = portRef.getParentCollection();
            if(parentCol) {
                parentCol->accept(*this);
            } else {
                if(!mIsPortInstanceContext) {
                    portRef.getParent()->accept(*this);
                }
            }
            mOut << ")";
        } else {
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

template<typename _Tp >

virtual void torc::generic::VisitorType< _Tp >::visit ( _Tp &  client ) throw ( Error )

pure virtualinherited

Visit the target object. This will typically be a derived leaf type.

Parameters

[in,out]

client

A reference to the target object

Exceptions

Error

Exception generated by any of the functions called from inside visit()

Here is the caller graph for this function:

void torc::generic::Decompiler::visit	(	VectorPortBitReference &	inVectorPortBitRef	)
throw	(	Error
	)

Definition at line 669 of file Decompiler.cpp.

                                                                   {
    try {
        Indenter indent(*this);
        if(mIsJoiningContext) {
            PortReferenceSharedPtr parent = bitRef.getParentCollection();
            mOut << std::endl << indent << "(portRef (member " << parent->getName() << " ";
            copy(bitRef.getIndices().begin(), bitRef.getIndices().end(),
                std::ostream_iterator < size_t > (mOut, " "));
            mOut << ")";
            PortReferenceSharedPtr parentCol = parent->getParentCollection();
            if(parentCol) {
                parentCol->accept(*this);
            } else {
                if(!mIsPortInstanceContext) {
                    parent->getParent()->accept(*this);
                }
            }
            mOut << ")";
        } else {
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	PortBundleReference &	inPortBundleRef	)
throw	(	Error
	)

Definition at line 743 of file Decompiler.cpp.

                                                                 {
    try {
        Indenter indent(*this);
        mOut << std::endl << indent << "(portRef " << portRef.getName() << " ";
        PortReferenceSharedPtr parentCol = portRef.getParentCollection();
        if(parentCol) {
            parentCol->accept(*this);
        } else {
            portRef.getParent()->accept(*this);
        }
        mOut << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	SingleParameter &	insingleParameter	)
throw	(	Error
	)

Definition at line 1054 of file Decompiler.cpp.

                                                                       {
    try {
        Indenter indent(*this);
        if(!mParamAssignContext) {
            if(!inSingleParameter.getOriginalName().empty()) {
                mOut << std::endl << indent << "(parameter ";
                mOut << std::endl << indent << "  (rename " << inSingleParameter.getName() << " "
                    << "\"" << inSingleParameter.getOriginalName() << "\"" << ")";
            } else {
                mOut << std::endl << indent << "(parameter " << inSingleParameter.getName() << " ";
            }
            printValueType(inSingleParameter.getValue());
            printValue(inSingleParameter.getValue());
            mOut << ")";
            printUnit(inSingleParameter.getUnit());
            mOut << ")";
        } else {
            mOut << std::endl << indent << "  (parameterAssign " << inSingleParameter.getName()
                << " ";
            printValueType(inSingleParameter.getValue());
            printValue(inSingleParameter.getValue());
            mOut << "))";
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	ParameterArray &	inparamArray	)
throw	(	Error
	)

Definition at line 1084 of file Decompiler.cpp.

                                                                 {
    try {
        Indenter indent(*this);
        if(!mParamAssignContext) {
            if(!inparamArray.getOriginalName().empty()) {
                mOut << std::endl << indent << "(parameter ";
                mOut << std::endl << indent << "  (array (rename " << inparamArray.getName() << " "
                    << "\"" << inparamArray.getOriginalName() << "\"" << ")" << " ";
            } else {
                mOut << std::endl << indent << "(parameter (array " << inparamArray.getName()
                    << " ";
            }
            std::vector < size_t > limits;
            inparamArray.getLimits(limits);
            copy(limits.begin(), limits.end(), std::ostream_iterator < size_t > (mOut, " "));
            mOut << ")" << std::endl << indent << "  ";
            std::vector<ParameterSharedPtr> children;
            inparamArray.getChildren(children);
            std::vector<ParameterSharedPtr>::iterator start = children.begin();
            std::vector<ParameterSharedPtr>::iterator end = children.end();
            printValueType((*start)->getValue());
            printArray(limits, limits.size(), start, end);
            mOut << ")";
            printUnit(inparamArray.getUnit());
            mOut << std::endl << indent << ")";
        } else {
            mOut << std::endl << indent << "  (parameterAssign " << inparamArray.getName();
            std::vector<ParameterSharedPtr> children;
            inparamArray.getChildren(children);
            if(!children.empty()) {
                std::vector < size_t > limits;
                inparamArray.getLimits(limits);
                std::vector<ParameterSharedPtr>::iterator start = children.begin();
                std::vector<ParameterSharedPtr>::iterator end = children.end();
                mOut << std::endl << indent << "    ";
                printValueType((*start)->getValue());
                printArray(limits, limits.size(), start, end);
                mOut << ")";
                mOut << std::endl << indent << "  )";
            }
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	ParameterArrayElement &	inParamArrayElement	)
throw	(	Error
	)

Definition at line 1131 of file Decompiler.cpp.

                                                               {
    try {
        printValue(bit.getValue());
        printUnit(bit.getUnit());
        mOut << " ";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	Property &	inProperty	)
throw	(	Error
	)

Definition at line 1143 of file Decompiler.cpp.

                                                         {
    try {
        Indenter indent(*this);
        if(!inProperty.getOriginalName().empty()) {
            mOut << std::endl << indent << "(property ";
            mOut << std::endl << indent << "  (rename " << inProperty.getName() << " " << "\""
                << inProperty.getOriginalName() << "\"" << ")";
        } else {
            mOut << std::endl << indent << "(property " << inProperty.getName();
        }
        printValueType(inProperty.getValue());
        printValue(inProperty.getValue());
        mOut << ")";

        if(!inProperty.getOwner().empty()) {
            mOut << std::endl << indent << "  (owner " << "\"" << inProperty.getOwner() << "\""
                << ")";
        }

        //Print Comments
        std::vector < std::string > comments = inProperty.getComments();
        printComments(comments);

        inProperty.applyOnAllChildren(mApplier);
        mOut << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	PortList &	inPortList	)
throw	(	Error
	)

Definition at line 1175 of file Decompiler.cpp.

                                                         {
    try {
        Indenter indent(*this);
        if(mIsJoiningContext) {
            std::list<PortList::PortListElement> elements;
            inPortList.getChildren(elements);
            mOut << std::endl << indent << "(portList ";
            for(std::list<PortList::PortListElement>::iterator it = elements.begin();
                it != elements.end(); ++it) {
                switch((*it).getType()) {
                case PortList::PortListElement::eElementTypePort: {
                    (*it).getPort()->accept(*this);
                    break;
                }
                case PortList::PortListElement::eElementTypePortReference: {
                    (*it).getPortReference()->accept(*this);
                    break;
                }
                }
            }
            mOut << std::endl << indent << ")";
        } else {
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	PortListAlias &	inPortListAlias	)
throw	(	Error
	)

Definition at line 1205 of file Decompiler.cpp.

                                                                   {
    try {
        Indenter indent(*this);
        mOut << std::endl << indent << "(portListAlias " << inPortListAlias.getName();
        mIsJoiningContext = true;
        inPortListAlias.getPortList()->accept(*this);
        mOut << std::endl << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	Status &	inStatus	)
throw	(	Error
	)

Definition at line 1219 of file Decompiler.cpp.

                                                   {
    try {
        Indenter indent(*this);
        mOut << std::endl << indent << "(status ";
        std::vector<WrittenSharedPtr> elements;
        status.getWrittens(elements);

        for(std::vector<WrittenSharedPtr>::iterator it = elements.begin(); it != elements.end();
            ++it) {
            mOut << std::endl << indent << "  (written ";
            mOut << std::endl << indent << "    (timeStamp ";
            WrittenSharedPtr written = *it;
            TimeStamp timestamp = written->getTimeStamp();
            mOut << timestamp.getYear() << " " << timestamp.getMonth() << " " << timestamp.getDay()
                << " " << timestamp.getHour() << " " << timestamp.getMinute() << " "
                << timestamp.getSecond() << ")";
            if(!written->getAuthorName().empty()) {
                mOut << std::endl << indent << "    (author " << "\"" << written->getAuthorName()
                    << "\"" << ")";
            }
            if(!written->getProgramName().empty()) {
                mOut << std::endl << indent << "    (program " << "\"" << written->getProgramName()
                    << "\"";
                if(!written->getProgramVersion().empty()) {
                    mOut << std::endl << indent << "      (version " << "\""
                        << written->getProgramVersion() << "\"" << ")";
                }
                mOut << ")";
            }

            if(!written->getDataOriginLocationName().empty()) {
                mOut << std::endl << indent << "    (dataOrigin " << "\""
                    << written->getDataOriginLocationName() << "\"";
                if(!written->getDataOriginVersion().empty()) {
                    mOut << std::endl << indent << "      (version " << "\""
                        << written->getDataOriginVersion() << "\"" << ")";
                }
                mOut << ")";
            }

            //Print Comments
            std::vector < std::string > comments = written->getComments();
            printComments(comments);

            std::list < std::string > userDatas;
            written->getUserData(userDatas);
            printUserData(userDatas);

            written->applyOnAllProperties(mApplier);

            mOut << std::endl << indent << "  )";
        }
        //Print Comments
        std::vector < std::string > comments = status.getComments();
        printComments(comments);

        std::list < std::string > userDatas;
        status.getUserData(userDatas);
        printUserData(userDatas);

        mOut << std::endl << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	Permutable &	inPermutable	)
throw	(	Error
	)

Definition at line 1287 of file Decompiler.cpp.

                                                             {
    try {
        mIsPermutableContext = true;
        Indenter indent(*this);
        if(mIsJoiningContext) {
            std::vector<PortSharedPtr> outPorts;
            inPermutable.getPorts(outPorts);
            if(!inPermutable.getIsNonPermutable()) {
                mOut << std::endl << indent << "(permutable ";
            } else {
                mOut << std::endl << indent << "(nonPermutable ";
            }
            std::vector<PortSharedPtr>::iterator port = outPorts.begin();
            std::vector<PortSharedPtr>::iterator end = outPorts.end();
            for(; port != end; ++port) {
                (*port)->accept(*this);
            }
            inPermutable.applyOnAllChildren(mApplier);
            mOut << std::endl << indent << ")";
        } else {
        }
        mIsPermutableContext = false;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	InterfaceJoinedInfo &	inInterfaceJoinedInfo	)
throw	(	Error
	)

Definition at line 1316 of file Decompiler.cpp.

                                                                               {
    try {
        mIsPermutableContext = true;
        Indenter indent(*this);
        if(mIsJoiningContext) {
            std::string joinedType;
            switch(inInterfaceJoinedInfo.getJoinedType()) {
            case InterfaceJoinedInfo::eJoinedTypeJoin: {
                joinedType = "joined";
                break;
            }
            case InterfaceJoinedInfo::eJoinedTypeWeak: {
                joinedType = "weakJoined";
                break;
            }
            case InterfaceJoinedInfo::eJoinedTypeMust: {
                joinedType = "mustJoin";
                break;
            }
            }
            mOut << std::endl << indent << "(" << joinedType;
            std::list<PortSharedPtr> outPorts;
            inInterfaceJoinedInfo.getPorts(outPorts);

            if(!outPorts.empty()) {
                std::list<PortSharedPtr>::iterator port = outPorts.begin();
                std::list<PortSharedPtr>::iterator end = outPorts.end();
                for(; port != end; ++port) {
                    (*port)->accept(*this);
                }
            }

            std::list<PortListSharedPtr> outPortLists;
            inInterfaceJoinedInfo.getPortLists(outPortLists);
            if(!outPortLists.empty()) {
                std::list<PortListSharedPtr>::iterator portList = outPortLists.begin();
                std::list<PortListSharedPtr>::iterator end = outPortLists.end();
                for(; portList != end; ++portList) {
                    (*portList)->accept(*this);
                }
            }

            inInterfaceJoinedInfo.applyOnAllChildren(mApplier);
            mOut << std::endl << indent << ")";
        } else {
        }
        mIsPermutableContext = false;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	SimulationInfo &	simuInfo	)
throw	(	Error
	)

Definition at line 1370 of file Decompiler.cpp.

                                                             {
    try {
        Indenter indent(*this);
        mOut << std::endl << indent << "(simulationInfo";
        simuInfo.applyOnAllLogicValues(mApplier);

        //Print Comments
        std::vector < std::string > comments = simuInfo.getComments();
        printComments(comments);

        //Print UserData
        std::list < std::string > elements;
        simuInfo.getUserData(elements);
        printUserData(elements);

        mOut << std::endl << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	Simulate &	simulate	)
throw	(	Error
	)

Definition at line 1393 of file Decompiler.cpp.

                                                       {
    try {
        Indenter indent(*this);
        if(!simulate.getOriginalName().empty()) {
            mOut << std::endl << indent << "(simulate (rename " << simulate.getName() << " " << "\""
                << simulate.getOriginalName() << "\"" << ")";
        } else {
            mOut << std::endl << indent << "(simulate " << simulate.getName();
        }

        simulate.applyOnAllPortListAlias(mApplier);
        simulate.applyOnAllWaveValues(mApplier);

        std::vector<ApplySharedPtr> outAllApply;
        simulate.getAllApply(outAllApply);
        std::vector<ApplySharedPtr>::iterator it = outAllApply.begin();
        for(; it != outAllApply.end(); it++) {
            (*it)->accept(*this);
        }

        //Print Comments
        std::vector < std::string > comments = simulate.getComments();
        printComments(comments);

        //Print UserData
        std::list < std::string > elements;
        simulate.getUserData(elements);
        printUserData(elements);

        mOut << std::endl << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	Apply &	apply	)
throw	(	Error
	)

Definition at line 1430 of file Decompiler.cpp.

                                                 {
    try {
        Indenter indent(*this);
        mOut << std::endl << indent << "(apply " << "(cycle " << apply.getNoOfCycle()
            << " (duration ";
        printValue(apply.getCycleDuration());
        mOut << "))";

        std::list<LogicalResponseSharedPtr> outLogicResponces;
        apply.getLogicResponses(outLogicResponces);
        std::list<LogicalResponseSharedPtr>::iterator logicIt = outLogicResponces.begin();
        for(; logicIt != outLogicResponces.end(); logicIt++) {
            (*logicIt)->accept(*this);
        }

        //Print Comments
        std::vector < std::string > comments = apply.getComments();
        printComments(comments);

        //Print UserData
        std::list < std::string > elements;
        apply.getUserData(elements);
        printUserData(elements);

        mOut << std::endl << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	LogicalResponse &	logicalResponse	)
throw	(	Error
	)

Definition at line 1462 of file Decompiler.cpp.

                                                                     {
    try {
        Indenter indent(*this);
        std::string responseType;
        switch(logicalResponse.getResponseType()) {
        case LogicalResponse::eResponseTypeInput: {
            responseType = "logicInput";
            break;
        }
        case LogicalResponse::eResponseTypeOutput: {
            responseType = "logicOutput";
            break;
        }
        }
        mOut << std::endl << indent << "(" << responseType;
        if(NULL != logicalResponse.getConnectedPort()) {
            mOut << " " << logicalResponse.getConnectedPort()->getName();
        }
        if(NULL != logicalResponse.getConnectedPortListAlias()) {
            mOut << " " << logicalResponse.getConnectedPortListAlias()->getName();
        }
        if(NULL != logicalResponse.getConnectedPortList()) {
            logicalResponse.getConnectedPortList()->accept(*this);
        }
        LogicElementSharedPtr logicElement = logicalResponse.getLogicWaveForm();
        if(logicElement) {
            logicElement->accept(*this);
        }
        mOut << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	LogicValue &	logicVal	)
throw	(	Error
	)

Definition at line 1565 of file Decompiler.cpp.

                                                         {
    try {
        Indenter indent(*this);
        if(!logicVal.getOriginalName().empty()) {
            mOut << std::endl << indent << "(logicValue ";
            mOut << std::endl << indent << "  (rename " << logicVal.getName() << " " << "\""
                << logicVal.getOriginalName() << "\"" << ")";
        } else {
            mOut << std::endl << indent << "(logicValue " << logicVal.getName();
        }

        //TBD
        //Print attributes
        printLogicValueAttributes(logicVal.getAttributes());

        //Print Comments
        std::vector < std::string > comments = logicVal.getComments();
        printComments(comments);

        logicVal.applyOnAllProperties(mApplier);

        //Print UserData
        std::list < std::string > elements;
        logicVal.getUserData(elements);
        printUserData(elements);

        mOut << std::endl << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	LogicElement &	logicElement	)
throw	(	Error
	)

Definition at line 1498 of file Decompiler.cpp.

                                                            {
    try {
        Indenter indent(*this);
        std::string type;
        std::string logicValueName;
        switch(logicElem.getType()) {
        case LogicElement::eTypeSingle: {
            type = "";
            logicValueName = logicElem.getName();
            break;
        }
        case LogicElement::eTypeList: {
            type = "logicList";
            break;
        }
        case LogicElement::eTypeOneOf: {
            type = "logicOneOf";
            break;
        }
        case LogicElement::eTypeWaveForm: {
            type = "logicWaveForm";
            break;
        }
        case LogicElement::eTypeIgnored: {
            type = "ignore";
            break;
        }
        case LogicElement::eTypeTransition: {
            type = "transition";
            break;
        }
        case LogicElement::eTypeBecomes: {
            type = "becomes";
            break;
        }
        }

        if(LogicElement::eTypeSingle == logicElem.getType()) {
            mOut << " " << logicValueName;
        } else {
            mOut << std::endl << indent << "(" << type;
            logicElem.applyOnAllChildren(mApplier);
            mOut << ")";
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	WaveValue &	waveValue	)
throw	(	Error
	)

Definition at line 1549 of file Decompiler.cpp.

                                                         {
    try {
        Indenter indent(*this);
        mOut << std::endl << indent << "(waveValue " << waveValue.getName() << " ";
        printValue(waveValue.getDeltaTimeDuration());
        if(NULL != waveValue.getLogicWaveform()) {
            waveValue.getLogicWaveform()->accept(*this);
        }
        mOut << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	Timing &	timing	)
throw	(	Error
	)

Definition at line 1599 of file Decompiler.cpp.

                                                   {
    try {
        Indenter indent(*this);
        mOut << std::endl << indent << "(timing " << std::endl;
        mOut << indent;
        printDerivation(timing.getDerivation());

        std::list<PathDelaySharedPtr> outPathDelays;
        timing.getPathDelays(outPathDelays);
        std::list<PathDelaySharedPtr>::iterator pathDelayIt = outPathDelays.begin();
        for(; pathDelayIt != outPathDelays.end(); pathDelayIt++) {
            mOut << indent << "    (pathDelay " << std::endl;
            mOut << indent << "        (delay ";
            PathDelaySharedPtr pathDelay = *pathDelayIt;
            Value::MiNoMax mnm = pathDelay->getDelay();
            Value val(Value::eValueTypeMiNoMax, mnm);
            printValue(val);
            mOut << ")" << std::endl;

            //Print event
            std::list<EventSharedPtr> outEvents;
            pathDelay->getEvents(outEvents);
            std::list<EventSharedPtr>::iterator eventIt = outEvents.begin();
            for(; eventIt != outEvents.end(); eventIt++) {
                mOut << "    ";
                (*eventIt)->accept(*this);
            }
            mOut << indent << "    )" << std::endl;
        }

        //Print forbiddenEvent
        std::list<ForbiddenEventSharedPtr> outForbiddentEvents;
        timing.getForbiddentEvents(outForbiddentEvents);
        std::list<ForbiddenEventSharedPtr>::iterator forbiddentEventIt =
            outForbiddentEvents.begin();
        for(; forbiddentEventIt != outForbiddentEvents.end(); forbiddentEventIt++) {
            (*forbiddentEventIt)->accept(*this);
        }

        //Print Comments
        std::vector < std::string > comments = timing.getComments();
        printComments(comments);

        //Print UserData
        std::list < std::string > elements;
        timing.getUserData(elements);
        printUserData(elements);

        mOut << std::endl << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	Event &	event	)
throw	(	Error
	)

Definition at line 1655 of file Decompiler.cpp.

                                                 {
    try {
        Indenter indent(*this);
        std::string type;
        switch(event.getType()) {
        case Event::eTypeEvent: {
            type = "(event";
            break;
        }
        case Event::eTypeOffsetEvent: {
            type = "(offsetEvent (event";
            break;
        }
        }

        mOut << indent << type;

        //Print port or portGroup
        mIsJoiningContext = true;
        std::list<PortElement> outPortElements;
        event.getPortElements(outPortElements);
        std::list<PortElement>::iterator portElem = outPortElements.begin();
        std::list<PortElement>::iterator end = outPortElements.end();
        if(outPortElements.size() > 1) {
            (*this).setIndentation((*this).getIndentation() + 8);
            mOut << std::endl << indent << "(portGroup";
        }
        if(outPortElements.size() == 1) {
            (*this).setIndentation((*this).getIndentation() + 4);
        }

        for(; portElem != end; ++portElem) {
            switch((*portElem).getType()) {
            case PortElement::eElementTypePort: {
                (*portElem).getPort()->accept(*this);
                break;
            }
            case PortElement::eElementTypePortReference: {
                (*portElem).getPortReference()->accept(*this);
                break;
            }
            }
        }

        if(outPortElements.size() > 1) {
            mOut << ")";
            (*this).setIndentation((*this).getIndentation() - 8);
        }
        if(outPortElements.size() == 1) {
            (*this).setIndentation((*this).getIndentation() - 4);
        }
        //Print portList
        if(NULL != event.getPortList()) {
            (*this).setIndentation((*this).getIndentation() + 4);
            event.getPortList()->accept(*this);
            (*this).setIndentation((*this).getIndentation() - 4);
        }
        //Print net or netGroup
        mIsJoiningContext = false;
        std::list<NetSharedPtr> outNets;
        event.getNets(outNets);
        std::list<NetSharedPtr>::iterator net = outNets.begin();
        if(outNets.size() > 1) {
            (*this).setIndentation((*this).getIndentation() + 8);
            mOut << std::endl << indent << "(netGroup";
        }
        if(outNets.size() == 1) {
            (*this).setIndentation((*this).getIndentation() + 4);
        }

        for(; net != outNets.end(); ++net) {
            (*net)->accept(*this);
        }

        if(outNets.size() > 1) {
            mOut << ")";
            (*this).setIndentation((*this).getIndentation() - 8);
        }
        if(outNets.size() == 1) {
            (*this).setIndentation((*this).getIndentation() - 4);
        }

        //Print transition/becomes
        if(NULL != event.getTransition()) {
            (*this).setIndentation((*this).getIndentation() + 4);
            event.getTransition()->accept(*this);
            (*this).setIndentation((*this).getIndentation() - 4);
        }

        switch(event.getType()) {
        case Event::eTypeEvent: {
            mOut << ")" << std::endl;
            break;
        }
        case Event::eTypeOffsetEvent: {
            mOut << ") "; //end of event
            printValue(event.getOffsetTime());
            mOut << ")" << std::endl;
            break;
        }
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Decompiler::visit	(	ForbiddenEvent &	forbiddenevent	)
throw	(	Error
	)

Definition at line 1763 of file Decompiler.cpp.

                                                                   {
    try {
        Indenter indent(*this);
        mOut << indent << "(forbiddenEvent" << std::endl;
        mOut << indent << "    (timeInterval" << std::endl;
        if(NULL != forbiddenevent.getStartTimeInterval()) {
            mOut << "    ";
            forbiddenevent.getStartTimeInterval()->accept(*this);
        }
        if(NULL != forbiddenevent.getEndTimeInterval()) {
            mOut << "    ";
            forbiddenevent.getEndTimeInterval()->accept(*this);
        } else {
            mOut << "    ";
            mOut << indent << "    (duration ";
            printValue(forbiddenevent.getDuration());
            mOut << ")" << std::endl;
        }
        mOut << indent << "    )" << std::endl;

        std::list<EventSharedPtr> outEvents;
        forbiddenevent.getEvents(outEvents);
        std::list<EventSharedPtr>::iterator eventIt = outEvents.begin();
        for(; eventIt != outEvents.end(); eventIt++) {
            (*eventIt)->accept(*this);
        }
        mOut << indent << ")";
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

Field Documentation

VisitorApplier<Decompiler> torc::generic::Decompiler::mApplier

private

Definition at line 170 of file Decompiler.hpp.

size_t torc::generic::Decompiler::mIndentation

private

Definition at line 169 of file Decompiler.hpp.

bool torc::generic::Decompiler::mIsExternContext

private

Definition at line 166 of file Decompiler.hpp.

bool torc::generic::Decompiler::mIsJoiningContext

private

Definition at line 164 of file Decompiler.hpp.

bool torc::generic::Decompiler::mIsPermutableContext

private

Definition at line 165 of file Decompiler.hpp.

bool torc::generic::Decompiler::mIsPortInstanceContext

private

Definition at line 168 of file Decompiler.hpp.

std::ostream& torc::generic::Decompiler::mOut

private

Definition at line 163 of file Decompiler.hpp.

bool torc::generic::Decompiler::mParamAssignContext

private

Definition at line 167 of file Decompiler.hpp.

RootSharedPtr torc::generic::Decompiler::mRoot

private

Definition at line 162 of file Decompiler.hpp.

---

The documentation for this class was generated from the following files:

• Decompiler.hpp
• Decompiler.cpp