adding bool param to parser visit() function

10 files changed, 67 insertions, 67 deletions

diff --git a/cpp/src/FreezeScript/DumpDB.cpp b/cpp/src/FreezeScript/DumpDB.cpp
index fb216883191..8e7a31efa0c 100644
--- a/cpp/src/FreezeScript/DumpDB.cpp
+++ b/cpp/src/FreezeScript/DumpDB.cpp
@@ -370,7 +370,7 @@ run(int argc, char** argv, const Ice::CommunicatorPtr& communicator)
         out << se("dumpdb");
 
         FreezeScript::SliceVisitor visitor(out, keyType, valueType, selectExpr);
-        unit->visit(&visitor);
+        unit->visit(&visitor, false);
 
         out << ee;
 
diff --git a/cpp/src/FreezeScript/TransformAnalyzer.cpp b/cpp/src/FreezeScript/TransformAnalyzer.cpp
index 8ea4bc5b0c4..3a6de591b58 100644
--- a/cpp/src/FreezeScript/TransformAnalyzer.cpp
+++ b/cpp/src/FreezeScript/TransformAnalyzer.cpp
@@ -1128,10 +1128,10 @@ FreezeScript::TransformAnalyzer::analyze(const TypePtr& oldKey, const TypePtr& n
 
     AnalyzeTransformVisitor transformVisitor(out, _new, oldKey, newKey, oldValue, newValue, _ignoreTypeChanges,
                                              missingTypes, errors);
-    _old->visit(&transformVisitor);
+    _old->visit(&transformVisitor, false);
 
     AnalyzeInitVisitor initVisitor(out, _old);
-    _new->visit(&initVisitor);
+    _new->visit(&initVisitor, false);
 
     out << ee;
     out << '\n';
diff --git a/cpp/src/Slice/Checksum.cpp b/cpp/src/Slice/Checksum.cpp
index eb73ad23561..7e3e2d03bbb 100644
--- a/cpp/src/Slice/Checksum.cpp
+++ b/cpp/src/Slice/Checksum.cpp
@@ -312,7 +312,7 @@ Slice::createChecksums(const UnitPtr& unit)
     ChecksumMap result;
 
     ChecksumVisitor visitor(result);
-    unit->visit(&visitor);
+    unit->visit(&visitor, false);
 
     return result;
 }
diff --git a/cpp/src/Slice/CsUtil.cpp b/cpp/src/Slice/CsUtil.cpp
index efe16a9162f..c1f30efedd6 100755
--- a/cpp/src/Slice/CsUtil.cpp
+++ b/cpp/src/Slice/CsUtil.cpp
@@ -760,7 +760,7 @@ void
 Slice::CsGenerator::validateMetaData(const UnitPtr& unit)
 {
     MetaDataVisitor visitor;
-    unit->visit(&visitor);
+    unit->visit(&visitor, false);
 }
 
 bool
diff --git a/cpp/src/Slice/JavaUtil.cpp b/cpp/src/Slice/JavaUtil.cpp
index 06e1dc9f331..97d467f1122 100644
--- a/cpp/src/Slice/JavaUtil.cpp
+++ b/cpp/src/Slice/JavaUtil.cpp
@@ -1399,7 +1399,7 @@ void
 Slice::JavaGenerator::validateMetaData(const UnitPtr& unit)
 {
     MetaDataVisitor visitor;
-    unit->visit(&visitor);
+    unit->visit(&visitor, false);
 }
 
 bool
diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp
index 32fb82caa0b..53f1a7e32f2 100644
--- a/cpp/src/Slice/Parser.cpp
+++ b/cpp/src/Slice/Parser.cpp
@@ -128,7 +128,7 @@ Slice::SyntaxTreeBase::definitionContext() const
 }
 
 void
-Slice::SyntaxTreeBase::visit(ParserVisitor*)
+Slice::SyntaxTreeBase::visit(ParserVisitor*, bool)
 {
 }
 
@@ -1734,13 +1734,13 @@ Slice::Container::sortContents()
 }
 
 void
-Slice::Container::visit(ParserVisitor* visitor)
+Slice::Container::visit(ParserVisitor* visitor, bool all)
 {
     for(ContainedList::const_iterator p = _contents.begin(); p != _contents.end(); ++p)
     {
-	if((*p)->includeLevel() == 0)
+	if(all || (*p)->includeLevel() == 0)
 	{
-	    (*p)->visit(visitor);
+	    (*p)->visit(visitor, all);
 	}
     }
 }
@@ -2091,11 +2091,11 @@ Slice::Module::kindOf() const
 }
 
 void
-Slice::Module::visit(ParserVisitor* visitor)
+Slice::Module::visit(ParserVisitor* visitor, bool all)
 {
     if(visitor->visitModuleStart(this))
     {
-	Container::visit(visitor);
+	Container::visit(visitor, all);
 	visitor->visitModuleEnd(this);
     }
 }
@@ -2217,7 +2217,7 @@ Slice::ClassDecl::kindOf() const
 }
 
 void
-Slice::ClassDecl::visit(ParserVisitor* visitor)
+Slice::ClassDecl::visit(ParserVisitor* visitor, bool)
 {
     visitor->visitClassDecl(this);
 }
@@ -2908,11 +2908,11 @@ Slice::ClassDef::kindOf() const
 }
 
 void
-Slice::ClassDef::visit(ParserVisitor* visitor)
+Slice::ClassDef::visit(ParserVisitor* visitor, bool all)
 {
     if(visitor->visitClassDefStart(this))
     {
-	Container::visit(visitor);
+	Container::visit(visitor, all);
 	visitor->visitClassDefEnd(this);
     }
 }
@@ -3247,11 +3247,11 @@ Slice::Exception::kindOf() const
 }
 
 void
-Slice::Exception::visit(ParserVisitor* visitor)
+Slice::Exception::visit(ParserVisitor* visitor, bool all)
 {
     if(visitor->visitExceptionStart(this))
     {
-	Container::visit(visitor);
+	Container::visit(visitor, all);
 	visitor->visitExceptionEnd(this);
     }
 }
@@ -3451,11 +3451,11 @@ Slice::Struct::kindOf() const
 }
 
 void
-Slice::Struct::visit(ParserVisitor* visitor)
+Slice::Struct::visit(ParserVisitor* visitor, bool all)
 {
     if(visitor->visitStructStart(this))
     {
-	Container::visit(visitor);
+	Container::visit(visitor, all);
 	visitor->visitStructEnd(this);
     }
 }
@@ -3528,7 +3528,7 @@ Slice::Sequence::kindOf() const
 }
 
 void
-Slice::Sequence::visit(ParserVisitor* visitor)
+Slice::Sequence::visit(ParserVisitor* visitor, bool)
 {
     visitor->visitSequence(this);
 }
@@ -3622,7 +3622,7 @@ Slice::Dictionary::kindOf() const
 }
 
 void
-Slice::Dictionary::visit(ParserVisitor* visitor)
+Slice::Dictionary::visit(ParserVisitor* visitor, bool)
 {
     visitor->visitDictionary(this);
 }
@@ -3798,7 +3798,7 @@ Slice::Enum::kindOf() const
 }
 
 void
-Slice::Enum::visit(ParserVisitor* visitor)
+Slice::Enum::visit(ParserVisitor* visitor, bool)
 {
     visitor->visitEnum(this);
 }
@@ -3887,7 +3887,7 @@ Slice::Const::kindOf() const
 }
 
 void
-Slice::Const::visit(ParserVisitor* visitor)
+Slice::Const::visit(ParserVisitor* visitor, bool)
 {
     visitor->visitConst(this);
 }
@@ -4390,7 +4390,7 @@ Slice::Operation::kindOf() const
 }
 
 void
-Slice::Operation::visit(ParserVisitor* visitor)
+Slice::Operation::visit(ParserVisitor* visitor, bool)
 {
     visitor->visitOperation(this);
 }
@@ -4448,7 +4448,7 @@ Slice::ParamDecl::kindOf() const
 }
 
 void
-Slice::ParamDecl::visit(ParserVisitor* visitor)
+Slice::ParamDecl::visit(ParserVisitor* visitor, bool)
 {
     visitor->visitParamDecl(this);
 }
@@ -4496,7 +4496,7 @@ Slice::DataMember::kindOf() const
 }
 
 void
-Slice::DataMember::visit(ParserVisitor* visitor)
+Slice::DataMember::visit(ParserVisitor* visitor, bool)
 {
     visitor->visitDataMember(this);
 }
@@ -5067,11 +5067,11 @@ Slice::Unit::destroy()
 }
 
 void
-Slice::Unit::visit(ParserVisitor* visitor)
+Slice::Unit::visit(ParserVisitor* visitor, bool all)
 {
     if(visitor->visitUnitStart(this))
     {
-	Container::visit(visitor);
+	Container::visit(visitor, all);
 	visitor->visitUnitEnd(this);
     }
 }
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index e214f8e1f7e..5d1e2a231c2 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -239,40 +239,40 @@ Slice::Gen::generate(const UnitPtr& p)
     }
 
     ProxyDeclVisitor proxyDeclVisitor(H, C, _dllExport);
-    p->visit(&proxyDeclVisitor);
+    p->visit(&proxyDeclVisitor, false);
 
     ObjectDeclVisitor objectDeclVisitor(H, C, _dllExport);
-    p->visit(&objectDeclVisitor);
+    p->visit(&objectDeclVisitor, false);
 
     IceInternalVisitor iceInternalVisitor(H, C, _dllExport);
-    p->visit(&iceInternalVisitor);
+    p->visit(&iceInternalVisitor, false);
 
     HandleVisitor handleVisitor(H, C, _dllExport);
-    p->visit(&handleVisitor);
+    p->visit(&handleVisitor, false);
 
     TypesVisitor typesVisitor(H, C, _dllExport);
-    p->visit(&typesVisitor);
+    p->visit(&typesVisitor, false);
 
     AsyncVisitor asyncVisitor(H, C, _dllExport);
-    p->visit(&asyncVisitor);
+    p->visit(&asyncVisitor, false);
 
     AsyncImplVisitor asyncImplVisitor(H, C, _dllExport);
-    p->visit(&asyncImplVisitor);
+    p->visit(&asyncImplVisitor, false);
 
     ProxyVisitor proxyVisitor(H, C, _dllExport);
-    p->visit(&proxyVisitor);
+    p->visit(&proxyVisitor, false);
 
     DelegateVisitor delegateVisitor(H, C, _dllExport);
-    p->visit(&delegateVisitor);
+    p->visit(&delegateVisitor, false);
 
     DelegateMVisitor delegateMVisitor(H, C, _dllExport);
-    p->visit(&delegateMVisitor);
+    p->visit(&delegateMVisitor, false);
 
     DelegateDVisitor delegateDVisitor(H, C, _dllExport);
-    p->visit(&delegateDVisitor);
+    p->visit(&delegateDVisitor, false);
 
     ObjectVisitor objectVisitor(H, C, _dllExport);
-    p->visit(&objectVisitor);
+    p->visit(&objectVisitor, false);
 
     if(_impl)
     {
@@ -291,7 +291,7 @@ Slice::Gen::generate(const UnitPtr& p)
         implC << _base << "I.h>";
 
         ImplVisitor implVisitor(implH, implC, _dllExport);
-        p->visit(&implVisitor);
+        p->visit(&implVisitor, false);
     }
 
     if(_checksum)
diff --git a/cpp/src/slice2cs/Gen.cpp b/cpp/src/slice2cs/Gen.cpp
index 1f5fdb3e860..22beb2daf7a 100755
--- a/cpp/src/slice2cs/Gen.cpp
+++ b/cpp/src/slice2cs/Gen.cpp
@@ -856,52 +856,52 @@ Slice::Gen::generate(const UnitPtr& p)
     CsGenerator::validateMetaData(p);
 
     TypesVisitor typesVisitor(_out);
-    p->visit(&typesVisitor);
+    p->visit(&typesVisitor, false);
 
     ProxyVisitor proxyVisitor(_out);
-    p->visit(&proxyVisitor);
+    p->visit(&proxyVisitor, false);
 
     OpsVisitor opsVisitor(_out);
-    p->visit(&opsVisitor);
+    p->visit(&opsVisitor, false);
 
     HelperVisitor helperVisitor(_out);
-    p->visit(&helperVisitor);
+    p->visit(&helperVisitor, false);
 
     DelegateVisitor delegateVisitor(_out);
-    p->visit(&delegateVisitor);
+    p->visit(&delegateVisitor, false);
 
     DelegateMVisitor delegateMVisitor(_out);
-    p->visit(&delegateMVisitor);
+    p->visit(&delegateMVisitor, false);
 
     DelegateDVisitor delegateDVisitor(_out);
-    p->visit(&delegateDVisitor);
+    p->visit(&delegateDVisitor, false);
 
     DispatcherVisitor dispatcherVisitor(_out);
-    p->visit(&dispatcherVisitor);
+    p->visit(&dispatcherVisitor, false);
 
     AsyncVisitor asyncVisitor(_out);
-    p->visit(&asyncVisitor);
+    p->visit(&asyncVisitor, false);
 }
 
 void
 Slice::Gen::generateTie(const UnitPtr& p)
 {
     TieVisitor tieVisitor(_out);
-    p->visit(&tieVisitor);
+    p->visit(&tieVisitor, false);
 }
 
 void
 Slice::Gen::generateImpl(const UnitPtr& p)
 {
     ImplVisitor implVisitor(_impl);
-    p->visit(&implVisitor);
+    p->visit(&implVisitor, false);
 }
 
 void
 Slice::Gen::generateImplTie(const UnitPtr& p)
 {
     ImplTieVisitor implTieVisitor(_impl);
-    p->visit(&implTieVisitor);
+    p->visit(&implTieVisitor, false);
 }
 
 void
diff --git a/cpp/src/slice2docbook/Gen.cpp b/cpp/src/slice2docbook/Gen.cpp
index 032f402b2e8..9a11ab93136 100644
--- a/cpp/src/slice2docbook/Gen.cpp
+++ b/cpp/src/slice2docbook/Gen.cpp
@@ -58,7 +58,7 @@ Slice::Gen::generate(const UnitPtr& p)
     //
     p->sortContents();
 
-    p->visit(this);
+    p->visit(this, false);
 }
 
 bool
diff --git a/cpp/src/slice2java/Gen.cpp b/cpp/src/slice2java/Gen.cpp
index dc63fa58cf1..d3f82f7cd94 100644
--- a/cpp/src/slice2java/Gen.cpp
+++ b/cpp/src/slice2java/Gen.cpp
@@ -936,55 +936,55 @@ Slice::Gen::generate(const UnitPtr& p)
     JavaGenerator::validateMetaData(p);
 
     OpsVisitor opsVisitor(_dir);
-    p->visit(&opsVisitor);
+    p->visit(&opsVisitor, false);
 
     TypesVisitor typesVisitor(_dir);
-    p->visit(&typesVisitor);
+    p->visit(&typesVisitor, false);
 
     HolderVisitor holderVisitor(_dir);
-    p->visit(&holderVisitor);
+    p->visit(&holderVisitor, false);
 
     HelperVisitor helperVisitor(_dir);
-    p->visit(&helperVisitor);
+    p->visit(&helperVisitor, false);
 
     ProxyVisitor proxyVisitor(_dir);
-    p->visit(&proxyVisitor);
+    p->visit(&proxyVisitor, false);
 
     DelegateVisitor delegateVisitor(_dir);
-    p->visit(&delegateVisitor);
+    p->visit(&delegateVisitor, false);
 
     DelegateMVisitor delegateMVisitor(_dir);
-    p->visit(&delegateMVisitor);
+    p->visit(&delegateMVisitor, false);
 
     DelegateDVisitor delegateDVisitor(_dir);
-    p->visit(&delegateDVisitor);
+    p->visit(&delegateDVisitor, false);
 
     DispatcherVisitor dispatcherVisitor(_dir);
-    p->visit(&dispatcherVisitor);
+    p->visit(&dispatcherVisitor, false);
 
     AsyncVisitor asyncVisitor(_dir);
-    p->visit(&asyncVisitor);
+    p->visit(&asyncVisitor, false);
 }
 
 void
 Slice::Gen::generateTie(const UnitPtr& p)
 {
     TieVisitor tieVisitor(_dir);
-    p->visit(&tieVisitor);
+    p->visit(&tieVisitor, false);
 }
 
 void
 Slice::Gen::generateImpl(const UnitPtr& p)
 {
     ImplVisitor implVisitor(_dir);
-    p->visit(&implVisitor);
+    p->visit(&implVisitor, false);
 }
 
 void
 Slice::Gen::generateImplTie(const UnitPtr& p)
 {
     ImplTieVisitor implTieVisitor(_dir);
-    p->visit(&implTieVisitor);
+    p->visit(&implTieVisitor, false);
 }
 
 void