Work around an apparent namespace-in-template scoping bug in MSVC on Windows

src/bin/align-text.cc

@@ -26,10 +26,9 @@ bool IsNotToken(const std::string &token) {
   return ! kaldi::IsToken(token);
 }
 
-int main(int argc, char *argv[]) {
-  using namespace kaldi;
-  typedef kaldi::int32 int32;
+namespace kaldi {
 
+int main(int argc, char *argv[]) {
   try {
     const char *usage =
         "Computes alignment between two sentences with the same key in the\n"
@@ -133,3 +132,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}

src/bin/extract-ctx.cc

@@ -29,7 +29,7 @@
 #include "tree/build-tree-questions.h"
 #include "fst/fstlib.h"
 
-using namespace kaldi;
+namespace kaldi {
 
 using std::vector;
 
@@ -212,4 +212,9 @@ int main(int argc, char *argv[]) {
   }
 }
 
+}  //namespace kaldi
 
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}

src/bin/phones-to-prons.cc

@@ -26,6 +26,8 @@
 #include "fst/fstlib.h"
 #include "fstext/fstext-lib.h"
 
+namespace kaldi {
+
 // Create FST that accepts the phone sequence, with any number
 // of word-start and word-end symbol in between each phone. 
 void CreatePhonesAltFst(const std::vector<int32> &phones,
@@ -60,10 +62,8 @@ void CreatePhonesAltFst(const std::vector<int32> &phones,
 }
 
 int main(int argc, char *argv[]) {
-  using namespace kaldi;
   using fst::VectorFst;
   using fst::StdArc;
-  typedef kaldi::int32 int32;
   try {
     const char *usage =
         "Convert pairs of (phone-level, word-level) transcriptions to\n"
@@ -220,4 +220,9 @@ int main(int argc, char *argv[]) {
   }
 }
 
+}  //namespace kaldi
+
 
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}

src/bin/post-to-phone-post.cc

@@ -23,11 +23,10 @@
 #include "hmm/transition-model.h"
 #include "hmm/posterior.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;  
-
     const char *usage =
         "Convert posteriors to phone-level posteriors\n"
         "See also: post-to-pdf-post, post-to-weights, get-post-on-ali\n"
@@ -75,3 +74,9 @@ int main(int argc, char *argv[]) {
   }
 }
 
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}

src/gmmbin/gmm-decode-nbest.cc

@@ -30,7 +30,7 @@
 #include "lat/kaldi-lattice.h" // for CompactLatticeArc
 #include "fstext/lattice-utils.h" // for ConvertLattice
 
-using namespace kaldi;
+namespace kaldi {
 
 fst::Fst<fst::StdArc> *ReadNetwork(std::string filename) {
   // read decoding network FST
@@ -67,8 +67,6 @@ fst::Fst<fst::StdArc> *ReadNetwork(std::string filename) {
 
 int main(int argc, char *argv[]) {
   try {
-    typedef kaldi::int32 int32;
-
     const char *usage =
       "Decode features using GMM-based model, producing N-best lattice output.\n"
       "Note: this program was mainly intended to validate the lattice generation\n"
@@ -245,4 +243,9 @@ int main(int argc, char *argv[]) {
   }
 }
 
+}  //namespace kaldi
+
 
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}

src/kwsbin/generate-proxy-keywords.cc

@@ -17,7 +17,6 @@
 // See the Apache 2 License for the specific language governing permissions and
 // limitations under the License.
 
-
 #include "base/kaldi-common.h"
 #include "util/common-utils.h"
 #include "fstext/fstext-utils.h"
@@ -53,15 +52,16 @@ bool PrintProxyFstPath(const VectorFst<StdArc> &proxy,
 }
 }
 
+using namespace fst;
+using kaldi::int32;
+using kaldi::uint64;
+using kaldi::BasicVectorHolder;
+using kaldi::ParseOptions;
+using kaldi::SequentialInt32VectorReader;
+using kaldi::TableWriter;
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    using namespace fst;
-    typedef kaldi::int32 int32;
-    typedef kaldi::uint64 uint64;
-    typedef StdArc::StateId StateId;
-    typedef StdArc::Weight Weight;
-
     const char *usage =
         "Convert the keywords into in-vocabulary words using the given phone\n"
         "level edit distance fst (E.fst). The large lexicon (L2.fst) and\n"

src/kwsbin/kws-index-union.cc

@@ -24,13 +24,17 @@
 #include "lat/kaldi-kws.h"
 #include "lat/kws-functions.h"
 
+using namespace fst;
+using kaldi::int32;
+using kaldi::uint64;
+using kaldi::KwsLexicographicArc;
+using kaldi::KwsLexicographicFst;
+using kaldi::ParseOptions;
+using kaldi::SequentialTableReader;
+using kaldi::TableWriter;
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    using namespace fst;
-    typedef kaldi::int32 int32;
-    typedef kaldi::uint64 uint64;
-
     const char *usage =
         "Take a union of the indexed lattices. The input index is in the T*T*T semiring and\n"
         "the output index is also in the T*T*T semiring. At the end of this program, encoded\n"

src/kwsbin/kws-search.cc

@@ -70,17 +70,25 @@ class VectorFstToKwsLexicographicFstMapper {
 
 }
 
+using namespace fst;
+using kaldi::int32;
+using kaldi::uint64;
+using kaldi::BasicVectorHolder;
+using kaldi::DecodeLabelUid;
+using kaldi::EncodeLabel;
+using kaldi::KwsLexicographicArc;
+using kaldi::KwsLexicographicFst;
+using kaldi::ParseOptions;
+using kaldi::RandomAccessTableReader;
+using kaldi::SequentialTableReader;
+using kaldi::TableWriter;
+using kaldi::VectorFstToKwsLexicographicFstMapper;
+
 int main(int argc, char *argv[]) {
+  typedef KwsLexicographicArc Arc;
+  typedef Arc::Weight Weight;
+  typedef Arc::StateId StateId;
   try {
-    using namespace kaldi;
-    using namespace fst;
-    typedef kaldi::int32 int32;
-    typedef kaldi::uint32 uint32;
-    typedef kaldi::uint64 uint64;
-    typedef KwsLexicographicArc Arc;
-    typedef Arc::Weight Weight;
-    typedef Arc::StateId StateId;
-
     const char *usage =
         "Search the keywords over the index. This program can be executed parallely, either\n"
         "on the index side or the keywords side; we use a script to combine the final search\n"

src/kwsbin/lattice-to-kws-index.cc

@@ -28,13 +28,32 @@
 #include "lat/kws-functions.h"
 #include "fstext/epsilon-property.h"
 
+using fst::VectorFst;
+using kaldi::int32;
+using kaldi::uint64;
+using kaldi::BaseFloat;
+using kaldi::ClusterLattice;
+using kaldi::CompactLattice;
+using kaldi::CompactLatticeStateTimes;
+using kaldi::CompactLatticeStateTimes;
+using kaldi::CreateFactorTransducer;
+using kaldi::DoFactorDisambiguation;
+using kaldi::DoFactorMerging;
+using kaldi::KwsLexicographicArc;
+using kaldi::KwsLexicographicFst;
+using kaldi::KwsProductFst;
+using kaldi::MaybeDoSanityCheck;
+using kaldi::OptimizeFactorTransducer;
+using kaldi::ParseOptions;
+using kaldi::RandomAccessInt32Reader;
+using kaldi::RandomAccessTableReader;
+using kaldi::RemoveLongSilences;
+using kaldi::SequentialCompactLatticeReader;
+using kaldi::SequentialTableReader;
+using kaldi::TableWriter;
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    using fst::VectorFst;
-    typedef kaldi::int32 int32;
-    typedef kaldi::uint64 uint64;
-
     const char *usage =
         "Create an inverted index of the given lattices. The output index is in the T*T*T\n"
         "semiring. For details for the semiring, please refer to Dogan Can and Muran Saraclar's"

src/latbin/lattice-add-trans-probs.cc

@@ -26,11 +26,10 @@
 #include "hmm/transition-model.h"
 #include "hmm/hmm-utils.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -90,3 +89,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}

src/latbin/lattice-arcgraph.cc

@@ -24,6 +24,8 @@
 #include "lat/kaldi-lattice.h"
 #include "hmm/transition-model.h"
 
+namespace kaldi {
+
 typedef fst::StdArc::StateId StateId;
 typedef fst::StdArc::Weight Weight;
 typedef fst::StdArc::Label Label;
@@ -135,9 +137,6 @@ void MapTransitionIdsToTransitionStates(kaldi::CompactLattice *lat,
 
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -263,3 +262,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}

src/latbin/lattice-compose.cc

@@ -23,11 +23,10 @@
 #include "fstext/fstext-lib.h"
 #include "lat/kaldi-lattice.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -164,3 +163,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}

src/latbin/lattice-determinize-pruned.cc

@@ -24,11 +24,10 @@
 #include "lat/push-lattice.h"
 #include "lat/minimize-lattice.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-
     const char *usage =
         "Determinize lattices, keeping only the best path (sequence of acoustic states)\n"
         "for each input-symbol sequence.  This version does pruning as part of the\n"
@@ -117,3 +116,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}

src/latbin/lattice-interp.cc

@@ -23,11 +23,10 @@
 #include "fstext/fstext-lib.h"
 #include "lat/kaldi-lattice.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -111,3 +110,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}