torc/generic/decompiler/Decompiler.cpp

// Torc - Copyright 2011 University of Southern California.  All Rights Reserved.
// $HeadURL: https://torc-isi.svn.sourceforge.net/svnroot/torc-isi/branches/staging/0.9/src/torc/generic/decompiler/Decompiler.cpp $
// $Id: Decompiler.cpp 10 2011-10-12 18:40:16Z nsteiner $

// This program is free software: you can redistribute it and/or modify it under the terms of the 
// GNU General Public License as published by the Free Software Foundation, either version 3 of the 
// License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See 
// the GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License along with this program.  If 
// not, see <http://www.gnu.org/licenses/>.

#ifndef HAVE_CONFIG_H
#include "torc/generic/config.h"
#endif 

#include "torc/generic/decompiler/Decompiler.hpp"
#include "torc/generic/om/PortAttributes.hpp"
#include "torc/generic/om/NetAttributes.hpp"
#include "torc/generic/om/TimeStamp.hpp"
#include "torc/generic/om/Written.hpp"
#include "torc/generic/om/InterfaceAttributes.hpp"
#include "torc/generic/om/LogicValueAttributes.hpp"
#include "torc/generic/om/PathDelay.hpp"

namespace {

using namespace torc::generic;
typedef std::vector< LibrarySharedPtr > Libraries;
typedef std::vector< CellSharedPtr > Cells;
typedef std::vector< ViewSharedPtr > Views;
typedef std::vector< InstanceSharedPtr > Instances;

std::string
trimLeading( const std::string &inBuffer ) {
    const size_t beginStr = inBuffer.find_first_of("(");
    if(beginStr != std::string::npos)
    {
        const size_t endStr = inBuffer.find_last_of(")");
        const size_t range = endStr - beginStr + 1;
        return inBuffer.substr(beginStr, range);
    }
    return std::string();
}

// Code for Trim Leading Spaces only
std::string
trimLeadingSpaces( const std::string &inBuffer ) {
    // Find the first character position after excluding leading blank spaces
    const size_t startpos = inBuffer.find_first_not_of(" \t"); 
    if( std::string::npos != startpos ) {
        return inBuffer.substr( startpos, std::string::npos );
    }
    return std::string();
}

struct CircularDependencyResolver {

    enum PrintType
    {
        ePrintTypeExtern,
        ePrintTypeConcrete
    };

    void
    resolve( const RootSharedPtr &inRoot )
    {
        SymTab<std::string, PrintType, true> discoveredLibs;
        Libraries libs;
        inRoot->getLibraries( libs );
        for( Libraries::iterator lib = libs.begin();
                lib != libs.end(); ++lib )
        {
            if( (*lib)->getIsExtern() )
            {
                PrintType type;
                if( !discoveredLibs.get((*lib)->getName(), type) )
                {
                    //Extern but not found
                    mExterns.push_back( *lib );
                    discoveredLibs.set( (*lib)->getName(),
                                            ePrintTypeExtern );
                }
                continue;
                //Views here will most likely have
                //no bodies anyway
            }
            discoveredLibs.set( (*lib)->getName(),
                                ePrintTypeConcrete );
            mConcreteLibs.push_back( *lib );
            Cells cells;
            (*lib)->getCells( cells );
            for( Cells::iterator cell = cells.begin();
                    cell != cells.end(); ++cell )
            {
                Views views;
                (*cell)->getViews( views );
                for( Views::iterator view = views.begin();
                        view != views.end(); ++view )
                {
                    Instances instances;
                    (*view)->getInstances( instances );
                    for( Instances::iterator inst
                                = instances.begin();
                            inst != instances.end(); ++inst )
                    {
                        switch( (*inst)->getCompositionType() )
                        {
                            case eCompositionTypeScalar:
                            {
                                checkLib( *inst, discoveredLibs );
                                break;
                            }
                            case eCompositionTypeVector:
                            {
                                Instances children;
                                (*inst)->getChildren( children );
                                for( Instances::iterator c
                                            = children.begin();
                                       c != children.end(); ++c )
                                {
                                    checkLib( *c, discoveredLibs );
                                }
                                break;            
                            }
                            default:
                            {
                            }
                        }
                    }
                }
            }
        }
    }

    void
    checkLib( const InstanceSharedPtr &inInst,
           SymTab<std::string, PrintType, true> &inDiscoveredLibs)
    {
        ViewSharedPtr iV = inInst->getMaster();
        LibrarySharedPtr targetL
                                    = iV->getParent()->getParent();
        PrintType type;
        if( !inDiscoveredLibs.get( targetL->getName(), type ) )
        {
            mExterns.push_back( targetL );
            inDiscoveredLibs.set( targetL->getName(),
                                                ePrintTypeExtern );
            //We will print extern for this...
            //concrete may come later...
        }
    }
    std::vector< LibrarySharedPtr > mExterns;    
    std::vector< LibrarySharedPtr > mConcreteLibs;    
};

class Indenter {
  public:
    size_t
    getIndentation() const throw();

    Indenter( Decompiler &inPrinter,
               bool inChangeIndentation = true    );
    ~Indenter();

  private:
    Decompiler &mPrinter;
    bool mChangeIndentation;
};

size_t
Indenter::getIndentation() const throw()
{
    return mPrinter.getIndentation();
}

Indenter::Indenter( Decompiler &inPrinter,
        bool inChangeIndentation)
  : mPrinter( inPrinter ),
    mChangeIndentation( inChangeIndentation ) {
    size_t indentation = getIndentation();
    indentation += (mChangeIndentation) ? 4 : 0;
    mPrinter.setIndentation( indentation );
}

Indenter::~Indenter()
{
    size_t indentation = getIndentation();
    indentation -= (mChangeIndentation) ? 4 : 0;
    mPrinter.setIndentation( indentation );
}

}

namespace std
{

std::ostream &
operator<<( std::ostream &outStream, const Indenter &indent )
{
    for( size_t i = 0; i < indent.getIndentation(); i++ )
    {
        outStream<<" ";
    }
    return outStream;
}

}

namespace torc {

namespace generic {

// For Root
void
Decompiler::visit( Root &root ) throw(Error)
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;
}

// For Design
void
Decompiler::visit( Design &design ) throw(Error)
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;
}


// For Library
void
Decompiler::visit( Library &library ) throw(Error)
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;
}

// For Cell
void
Decompiler::visit( Cell &cell ) throw(Error)
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;
}

// For View
void
Decompiler::visit( View &view ) throw(Error)
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;
}

// For ScalarPort
void
Decompiler::visit( ScalarPort &port ) throw(Error)
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;
}

// For ScalarPortReference
void
Decompiler::visit( ScalarPortReference &portRef ) throw(Error)
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;
}

// For VectorPort
void
Decompiler::visit( VectorPort &port ) throw(Error)
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;
}   

// For VectorPortReference
void
Decompiler::visit( VectorPortReference &portRef ) throw(Error)
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;
}

// For VectorPortBit
void
Decompiler::visit( VectorPortBit &bit ) throw(Error)
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;
}

// For VectorPortBitReference
void
Decompiler::visit( VectorPortBitReference &bitRef ) throw(Error)
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;
}

// For PortBundle
void
Decompiler::visit( PortBundle &port ) throw(Error)
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;
}

// For PortBundleReference
void
Decompiler::visit( PortBundleReference &portRef ) throw(Error)
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;
}

// For SingleInstance
void
Decompiler::visit( SingleInstance &instance ) throw(Error)
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;
}

// For ScalarNet
void
Decompiler::visit( ScalarNet &net ) throw(Error)
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;
}

// For NetBundle
void
Decompiler::visit( NetBundle &net ) throw(Error)
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;
}

// For VectorNet
void
Decompiler::visit( VectorNet &net ) throw(Error)
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;
}

// For VectorNetBit
void
Decompiler::visit( VectorNetBit &net ) throw(Error)
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;
}

// For InstanceArray
void
Decompiler::visit( InstanceArray &instanceArray ) throw(Error)
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;
}

// For InstanceArrayMember
void
Decompiler::visit( InstanceArrayMember &instance ) throw(Error)
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;
}

// For SingleParameter
void
Decompiler::visit(SingleParameter &inSingleParameter) throw(Error)
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;
}

// For ParameterArray
void
Decompiler::visit(ParameterArray &inparamArray) throw(Error)
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;
}

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

//For Property
void
Decompiler::visit(Property &inProperty) throw(Error)
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;
}

// For PortList
void
Decompiler::visit(PortList &inPortList) throw(Error)
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;
}

// For PortListAlias
void
Decompiler::visit(PortListAlias &inPortListAlias) throw(Error)
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;
}
//For Status
void
Decompiler::visit(Status &status) throw(Error)
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;
}

//For Permutable
void
Decompiler::visit(Permutable &inPermutable) throw(Error)
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 >::const_iterator port = outPorts.begin();
        std::vector< PortSharedPtr >::const_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;
}

//For InterfaceJoinedInfo
void
Decompiler::visit(InterfaceJoinedInfo & inInterfaceJoinedInfo) throw(Error)
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 >::const_iterator port = outPorts.begin();
            std::list< PortSharedPtr >::const_iterator end =  outPorts.end();
            for(;port != end; ++port)
            {
                (*port)->accept( *this );
            }
        }

        std::list< PortListSharedPtr > outPortLists;
        inInterfaceJoinedInfo.getPortLists( outPortLists );
        if( !outPortLists.empty() )
        {
            std::list< PortListSharedPtr >::const_iterator portList = outPortLists.begin();
            std::list< PortListSharedPtr >::const_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;
}

// For SimulationInfo
void
Decompiler::visit( SimulationInfo &simuInfo ) throw(Error)
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;
}

// For Simulate
void
Decompiler::visit( Simulate &simulate ) throw(Error)
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;
}

// For Apply
void
Decompiler::visit( Apply & apply ) throw(Error)
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;
}

// For LogicalResponse logicInput/logicOutput()
void
Decompiler::visit( LogicalResponse & logicalResponse ) throw(Error)
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;
}

// For LogicElement
void
Decompiler::visit( LogicElement &logicElem ) throw(Error)
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;
}

//For WaveValue
void
Decompiler::visit(WaveValue & waveValue) throw(Error)
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;
}

// For LogicValue
void
Decompiler::visit( LogicValue &logicVal ) throw(Error)
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 );

    //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;
}

// For Timing
void
Decompiler::visit( Timing & timing ) throw(Error)
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;
}

//For Event
void
Decompiler::visit(Event & event ) throw(Error)
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 >::const_iterator portElem = outPortElements.begin();
    std::list< PortElement >::const_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 >::const_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;
}

//For ForbiddenEvent
void
Decompiler::visit(ForbiddenEvent & forbiddenevent ) throw(Error)
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;
}

// For UserData
void
Decompiler::printUserData( std::list< std::string > inElements) throw(Error)
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;
}

// For Comment
void
Decompiler::printComments( std::vector< std::string > & inElements) throw(Error) 
{
    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;
    }
}
void
Decompiler::printValueType( const Value &value ) throw(Error)
{
    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
Decompiler::printValue( const Value &value ) throw(Error)
{
    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:
        {
        }
    }
}

void
Decompiler::printUnit( const Unit unit ) throw(Error)
{
    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
Decompiler::printDerivation( const Derivation derivation ) throw(Error)
{    
    mOut<<"    (derivation ";        
    switch( derivation )
    {
        case eDerivationCalculated:
        {
            mOut<<"CALCULATED";
            break;
        }
        case eDerivationMeasured:
        {
            mOut<<"MEASURED";
            break;
        }
        case eDerivationRequired:
        {
            mOut<<"REQUIRED";
            break;
        }
        default:
        {
        }
    }
    mOut<<")"<<std::endl;
}

void
Decompiler::printArray(const std::vector<size_t> &outVector, size_t depth,
                        std::vector< ParameterSharedPtr >::iterator &itStart,
                        std::vector< ParameterSharedPtr >::iterator &itEnd) throw (Error)
{
    Indenter indent(*this);
    
    size_t array_size = outVector.size();
    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
Decompiler::printPortAttributes(
        const PortAttributesSharedPtr &inAttrib ) throw(Error) {
    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;
    }
}

void
Decompiler::printNetAttributes(
        const NetAttributesSharedPtr &inAttrib ) throw(Error) {
    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;
    }
}

void
Decompiler::printViewInterfaceAttributes(
        const InterfaceAttributesSharedPtr &inAttrib ) throw(Error) {
    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;
    }
}

//For LogicValueAttributes
void
Decompiler::printLogicValueAttributes(
        const LogicValueAttributesSharedPtr &inAttrib ) throw(Error) {

    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;
    }
}
void
Decompiler::operator()() throw(Error)
try
{
    decompile();    
}
catch( Error &e )
{
    e.setCurrentLocation(
        __FUNCTION__, __FILE__, __LINE__ );
    throw;
}

/**
 * Decompile the tree.
 * 
 * @param[in] root Root of the OM tree.
 */
void
Decompiler::decompile() throw(Error) {
    try
    {
        mRoot->accept( *this );
    }
    catch( Error &e )
    {
        e.setCurrentLocation(
            __FUNCTION__, __FILE__, __LINE__ );
        throw;
    }
}

void
Decompiler::setIndentation( size_t inIndentation ) throw()
{
    mIndentation = inIndentation;
}

Decompiler::Decompiler(const RootSharedPtr &inRoot,
                                            std::ostream &outStream)
    :mRoot( inRoot ),
    mOut( outStream ),
    mIsJoiningContext( false ),
    mIsPermutableContext( false ),
    mIsExternContext( false ),
    mParamAssignContext( false ),
    mIsPortInstanceContext( false ),
    mIndentation( 0 ),
    mApplier(*this){
}

Decompiler::~Decompiler() throw() {
}

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

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

} // namespace torc::generic

} // namespace torc

---