Logo Search packages:      
Sourcecode: fauhdlc version File versions

NullVisitor.cpp

/* $Id: NullVisitor.cpp 4323 2009-01-27 13:48:12Z potyra $ 
 * NullVisitor: base class for visitors that don't want any default traversal.
 *
 * Copyright (C) 2007-2009 FAUmachine Team <info@faumachine.org>.
 * This program is free software. You can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either version 2 of
 * the License, or (at your option) any later version. See COPYING.
 */

#include "frontend/visitor/NullVisitor.hpp"
#include "frontend/ast/ConstInteger.hpp"
#include "frontend/ast/ConstReal.hpp"
#include "frontend/ast/ConstArray.hpp"
#include "frontend/ast/Entity.hpp"
#include "frontend/ast/SymbolDeclaration.hpp"
#include "frontend/ast/ValDeclaration.hpp"
#include "frontend/ast/SignalDeclaration.hpp"
#include "frontend/ast/ConstantDeclaration.hpp"
#include "frontend/ast/Expression.hpp"
#include "frontend/ast/IfStat.hpp"
#include "frontend/ast/NullStat.hpp"
#include "frontend/ast/ForLoopStat.hpp"
#include "frontend/ast/WhileLoopStat.hpp"
#include "frontend/ast/NextStat.hpp"
#include "frontend/ast/VarAssignStat.hpp"
#include "frontend/ast/WaitStat.hpp"
#include "frontend/ast/ExitStat.hpp"
#include "frontend/ast/SigAssignStat.hpp"
#include "frontend/ast/WaveFormElem.hpp"
#include "frontend/ast/ReturnStat.hpp"
#include "frontend/ast/ProcCallStat.hpp"
#include "frontend/ast/AssertStat.hpp"
#include "frontend/ast/VarDeclaration.hpp"
#include "frontend/ast/DiscreteRange.hpp"
#include "frontend/ast/CaseStat.hpp"
#include "frontend/ast/CaseAlternative.hpp"
#include "frontend/ast/Others.hpp"
#include "frontend/ast/Architecture.hpp"
#include "frontend/ast/AssociationElement.hpp"
#include "frontend/ast/FunctionDeclaration.hpp"
#include "frontend/ast/ProcedureDeclaration.hpp"
#include "frontend/ast/CompInstStat.hpp"
#include "frontend/ast/Package.hpp"
#include "frontend/ast/PackageBody.hpp"
#include "frontend/ast/Process.hpp"
#include "frontend/ast/SubprogBody.hpp"
#include "frontend/ast/CondalSigAssign.hpp"
#include "frontend/ast/EnumerationType.hpp"
#include "frontend/ast/PhysicalType.hpp"
#include "frontend/ast/PhysicalTypeUnit.hpp"
#include "frontend/ast/RangeConstraintType.hpp"
#include "frontend/ast/UnconstrainedArrayType.hpp"
#include "frontend/ast/RecordType.hpp"
#include "frontend/ast/Aggregate.hpp"
#include "frontend/ast/EnumerationElement.hpp"
#include "frontend/ast/FunctionCall.hpp"
#include "frontend/ast/ElementAssociation.hpp"
#include "frontend/ast/SubtypeIndication.hpp"
#include "frontend/ast/Library.hpp"
#include "frontend/ast/LibraryList.hpp"
#include "frontend/ast/Subscript.hpp"
#include "frontend/ast/Slice.hpp"
#include "frontend/ast/TemporaryName.hpp"
#include "frontend/ast/SelectedName.hpp"
#include "frontend/ast/AttributeName.hpp"
#include "frontend/ast/TypeConversion.hpp"
#include "frontend/ast/AttributeDeclaration.hpp"
#include "frontend/ast/AttributeSpecification.hpp"

namespace ast {

void
00073 NullVisitor::visit(ElementAssociation& node)
{
      this->process(node);
}

void
00079 NullVisitor::visit(ConstReal& node)
{
      this->process(node);
}

void
00085 NullVisitor::visit(ConstArray &node)
{
      this->process(node);
}

void 
00091 NullVisitor::visit(SimpleName &node)
{
      this->process(node);
}

void 
00097 NullVisitor::visit(TemporaryName &node)
{
      this->process(node);
}

void 
00103 NullVisitor::visit(SelectedName &node)
{
      this->process(node);
}

void 
00109 NullVisitor::visit(AttributeName &node)
{
      this->process(node);
}

void
00115 NullVisitor::visit(Entity& node)
{
      this->process(node);
}

void
00121 NullVisitor::visit(LibraryList& node)
{
      this->process(node);
}

void
00127 NullVisitor::visit(SignalDeclaration& node)
{
      this->process(node);
}

void
00133 NullVisitor::visit(ConstantDeclaration& node)
{
      this->process(node);
}

void
00139 NullVisitor::visit(FunctionCall& node)
{
      this->process(node);
}

void
00145 NullVisitor::visit(IfStat& node)
{
      this->process(node);
}

void
00151 NullVisitor::visit(NullStat& node)
{
      this->process(node);
}

void
00157 NullVisitor::visit(ForLoopStat& node)
{
      this->process(node);
}

void
00163 NullVisitor::visit(WhileLoopStat& node)
{
      this->process(node);
}

void 
00169 NullVisitor::visit(NextStat& node) 
{
      this->process(node);
}

void 
00175 NullVisitor::visit(VarAssignStat& node) 
{
      this->process(node);
}

void 
00181 NullVisitor::visit(WaitStat& node) 
{
      this->process(node);
}

void 
00187 NullVisitor::visit(ExitStat& node) 
{
      this->process(node);
}

void 
00193 NullVisitor::visit(SigAssignStat& node) 
{
      this->process(node);
}

void 
00199 NullVisitor::visit(WaveFormElem& node) 
{
      this->process(node);
}

void 
00205 NullVisitor::visit(ReturnStat& node) 
{
      this->process(node);
}

void 
00211 NullVisitor::visit(ProcCallStat& node) 
{
      this->process(node);

}

void 
00218 NullVisitor::visit(AssertStat& node) 
{
      this->process(node);
}

void 
00224 NullVisitor::visit(VarDeclaration& node) 
{
      this->process(node);
}

void 
00230 NullVisitor::visit(DiscreteRange& node) 
{
      this->process(node);
}


void 
00237 NullVisitor::visit(CaseStat& node) 
{
      this->process(node);
}

void 
00243 NullVisitor::visit(CaseAlternative& node) 
{
      this->process(node);
}

void 
00249 NullVisitor::visit(Others& node) 
{
      this->process(node);
}

void 
00255 NullVisitor::visit(Architecture& node) 
{
      this->process(node);
}

void 
00261 NullVisitor::visit(AssociationElement& node) 
{
      this->process(node);
}

void 
00267 NullVisitor::visit(FunctionDeclaration& node) 
{
      this->process(node);
}

void 
00273 NullVisitor::visit(ProcedureDeclaration& node) 
{
      this->process(node);
}

void 
00279 NullVisitor::visit(CompInstStat& node) 
{
      this->process(node);
}

void 
00285 NullVisitor::visit(Package& node) 
{
      this->process(node);
}

void 
00291 NullVisitor::visit(PackageBody& node) 
{
      this->process(node);
}

void 
00297 NullVisitor::visit(Process& node) 
{
      this->process(node);
}

void 
00303 NullVisitor::visit(SubprogBody& node) 
{
      this->process(node);
}

void 
00309 NullVisitor::visit(CondalSigAssign& node) 
{
      this->process(node);
}

void 
00315 NullVisitor::visit(EnumerationType& node) 
{
      this->process(node);
}

void 
00321 NullVisitor::visit(PhysicalType& node) 
{
      this->process(node);
}

void 
00327 NullVisitor::visit(PhysicalTypeUnit& node) 
{
      this->process(node);
}

void 
00333 NullVisitor::visit(RangeConstraintType& node) 
{
      this->process(node);
}

void 
00339 NullVisitor::visit(UnconstrainedArrayType& node) 
{
      this->process(node);
}

void 
00345 NullVisitor::visit(RecordType& node) 
{
      this->process(node);
}

void
00351 NullVisitor::visit(RecordTypeElement& node)
{
      this->process(node);
}

void
00357 NullVisitor::visit(Aggregate& node)
{
      this->process(node);
}

void
00363 NullVisitor::visit(EnumerationElement& node)
{
      this->process(node);
}

void
00369 NullVisitor::visit(SubtypeIndication& node)
{
      this->process(node);
}

void
00375 NullVisitor::visit(Library& node)
{
      this->process(node);
}

void
00381 NullVisitor::visit(Subscript& node)
{
      this->process(node);
}

void
00387 NullVisitor::visit(Slice &node)
{
      this->process(node);
}

void
00393 NullVisitor::visit(ConstInteger &node)
{
      this->process(node);
}

void
00399 NullVisitor::visit(TypeConversion &node)
{
      this->process(node);
}

void
00405 NullVisitor::visit(AttributeDeclaration &node)
{
      this->process(node);
}

void
00411 NullVisitor::visit(AttributeSpecification &node)
{
      this->process(node);
}

void
00417 NullVisitor::process(ValDeclaration &node)
{
      SymbolDeclaration& sNode = static_cast<SymbolDeclaration&>(node);
      this->process(sNode);
}

void
00424 NullVisitor::process(SymbolDeclaration &node) 
{
      AstNode& aNode = static_cast<AstNode&>(node);
      this->process(aNode);
}

void
00431 NullVisitor::process(Expression &node) 
{
      AstNode& aNode = static_cast<AstNode&>(node);
      this->process(aNode);
}

void
00438 NullVisitor::process(SeqStat &node) 
{
      AstNode& anode = static_cast<AstNode&>(node);
      this->process(anode);
}

void
00445 NullVisitor::process(LoopStat &node) 
{
      SeqStat& snode = static_cast<SeqStat&>(node);
      this->process(snode);

}

void
00453 NullVisitor::process(ConditionedStat &node) 
{
      SeqStat& snode = static_cast<SeqStat&>(node);
      this->process(snode);
}

void
00460 NullVisitor::process(Callable &node) 
{
      SymbolDeclaration& snode = static_cast<SymbolDeclaration&>(node);
      this->process(snode);
}

void
00467 NullVisitor::process(LibUnit &node) 
{
      AttributableDeclaration& snode = 
            static_cast<AttributableDeclaration&>(node);
      this->process(snode);
}

void
00475 NullVisitor::process(TypeDeclaration &node) 
{
      SymbolDeclaration& snode = static_cast<SymbolDeclaration&>(node);
      this->process(snode);
}

void
00482 NullVisitor::process(PrefixedName &node) 
{
      Name &n = static_cast<Name&>(node);
      this->process(n);
}

void
00489 NullVisitor::process(Name &node) 
{
      Expression& exp = static_cast<Expression&>(node);
      this->process(exp);
}

void
00496 NullVisitor::process(AttributableDeclaration &node)
{
      SymbolDeclaration &snode = static_cast<SymbolDeclaration &>(node);
      this->process(snode);
}


}; /* namespace ast */

Generated by  Doxygen 1.6.0   Back to index