Updated OpenFST version to openfst-1.3.2-CL32004048 from Greco3.

Change-Id: I19b0db718256b35c0e3e5a7315f1ed6335e6dcac

1 files changed, 58 insertions, 10 deletions

diff --git a/src/include/fst/compose.h b/src/include/fst/compose.h
index c0bf4b1..dfdff0a 100644
--- a/src/include/fst/compose.h
+++ b/src/include/fst/compose.h
@@ -360,6 +360,10 @@ class ComposeFstImpl : public ComposeFstImplBase<typename M1::Arc> {
     return Times(final1, final2);
   }
 
+  // Identifies and verifies the capabilities of the matcher to be used for
+  // composition.
+  void SetMatchType();
+
   F *filter_;
   Matcher1 *matcher1_;
   Matcher2 *matcher2_;
@@ -385,14 +389,63 @@ ComposeFstImpl<M1, M2, F, T>::ComposeFstImpl(
       fst2_(matcher2_->GetFst()),
       state_table_(opts.state_table ? opts.state_table :
                    new T(fst1_, fst2_)) {
+  SetMatchType();
+  if (match_type_ == MATCH_NONE)
+    SetProperties(kError, kError);
+  VLOG(2) << "ComposeFst(" << this << "): Match type: "
+          << (match_type_ == MATCH_OUTPUT ? "output" :
+              (match_type_ == MATCH_INPUT ? "input" :
+               (match_type_ == MATCH_BOTH ? "both" :
+                (match_type_ == MATCH_NONE ? "none" : "unknown"))));
+
+  uint64 fprops1 = fst1.Properties(kFstProperties, false);
+  uint64 fprops2 = fst2.Properties(kFstProperties, false);
+  uint64 mprops1 = matcher1_->Properties(fprops1);
+  uint64 mprops2 = matcher2_->Properties(fprops2);
+  uint64 cprops = ComposeProperties(mprops1, mprops2);
+  SetProperties(filter_->Properties(cprops), kCopyProperties);
+  if (state_table_->Error()) SetProperties(kError, kError);
+  VLOG(2) << "ComposeFst(" << this << "): Initialized";
+}
+
+template <class M1, class M2, class F, class T>
+void ComposeFstImpl<M1, M2, F, T>::SetMatchType() {
   MatchType type1 = matcher1_->Type(false);
   MatchType type2 = matcher2_->Type(false);
-  if (type1 == MATCH_OUTPUT && type2  == MATCH_INPUT) {
+  uint32 flags1 = matcher1_->Flags();
+  uint32 flags2 = matcher2_->Flags();
+  if (flags1 & flags2 & kRequireMatch) {
+    FSTERROR() << "ComposeFst: only one argument can require matching.";
+    match_type_ = MATCH_NONE;
+  } else if (flags1 & kRequireMatch) {
+    if (matcher1_->Type(true) != MATCH_OUTPUT) {
+      FSTERROR() << "ComposeFst: 1st argument requires matching but cannot.";
+      match_type_ = MATCH_NONE;
+    }
+    match_type_ = MATCH_OUTPUT;
+  } else if (flags2 & kRequireMatch) {
+    if (matcher2_->Type(true) != MATCH_INPUT) {
+      FSTERROR() << "ComposeFst: 2nd argument requires matching but cannot.";
+      match_type_ = MATCH_NONE;
+    }
+    match_type_ = MATCH_INPUT;
+  } else if (flags1 & flags2 & kPreferMatch &&
+             type1 == MATCH_OUTPUT && type2  == MATCH_INPUT) {
+    match_type_ = MATCH_BOTH;
+  } else if (flags1 & kPreferMatch && type1 == MATCH_OUTPUT) {
+    match_type_ = MATCH_OUTPUT;
+  } else if  (flags2 & kPreferMatch && type2 == MATCH_INPUT) {
+    match_type_ = MATCH_INPUT;
+  } else if (type1 == MATCH_OUTPUT && type2  == MATCH_INPUT) {
     match_type_ = MATCH_BOTH;
   } else if (type1 == MATCH_OUTPUT) {
     match_type_ = MATCH_OUTPUT;
   } else if (type2 == MATCH_INPUT) {
     match_type_ = MATCH_INPUT;
+  } else if (flags1 & kPreferMatch && matcher1_->Type(true) == MATCH_OUTPUT) {
+    match_type_ = MATCH_OUTPUT;
+  } else if  (flags2 & kPreferMatch && matcher2_->Type(true) == MATCH_INPUT) {
+    match_type_ = MATCH_INPUT;
   } else if (matcher1_->Type(true) == MATCH_OUTPUT) {
     match_type_ = MATCH_OUTPUT;
   } else if (matcher2_->Type(true) == MATCH_INPUT) {
@@ -400,16 +453,8 @@ ComposeFstImpl<M1, M2, F, T>::ComposeFstImpl(
   } else {
     FSTERROR() << "ComposeFst: 1st argument cannot match on output labels "
                << "and 2nd argument cannot match on input labels (sort?).";
-    SetProperties(kError, kError);
+    match_type_ = MATCH_NONE;
   }
-  uint64 fprops1 = fst1.Properties(kFstProperties, false);
-  uint64 fprops2 = fst2.Properties(kFstProperties, false);
-  uint64 mprops1 = matcher1_->Properties(fprops1);
-  uint64 mprops2 = matcher2_->Properties(fprops2);
-  uint64 cprops = ComposeProperties(mprops1, mprops2);
-  SetProperties(filter_->Properties(cprops), kCopyProperties);
-  if (state_table_->Error()) SetProperties(kError, kError);
-  VLOG(2) << "ComposeFst(" << this << "): Initialized";
 }
 
 
@@ -539,16 +584,19 @@ class ComposeFst : public ImplToFst< ComposeFstImplBase<A> > {
     switch (LookAheadMatchType(fst1, fst2)) {  // Check for lookahead matchers
       default:
       case MATCH_NONE: {     // Default composition (no look-ahead)
+        VLOG(2) << "ComposeFst: Default composition (no look-ahead)";
         ComposeFstOptions<Arc> nopts(opts);
         return CreateBase1(fst1, fst2, nopts);
       }
       case MATCH_OUTPUT: {   // Lookahead on fst1
+        VLOG(2) << "ComposeFst: Lookahead on fst1";
         typedef typename DefaultLookAhead<Arc, MATCH_OUTPUT>::FstMatcher M;
         typedef typename DefaultLookAhead<Arc, MATCH_OUTPUT>::ComposeFilter F;
         ComposeFstOptions<Arc, M, F> nopts(opts);
         return CreateBase1(fst1, fst2, nopts);
       }
       case MATCH_INPUT: {    // Lookahead on fst2
+        VLOG(2) << "ComposeFst: Lookahead on fst2";
         typedef typename DefaultLookAhead<Arc, MATCH_INPUT>::FstMatcher M;
         typedef typename DefaultLookAhead<Arc, MATCH_INPUT>::ComposeFilter F;
         ComposeFstOptions<Arc, M, F> nopts(opts);