commit 890357653f6556d64e54f3485edb280d80f12126
Author: Tanmai Khanna <khanna.tanmai@gmail.com>
Date:   Tue Aug 13 11:47:01 2019 +0530

    Changes for Anaphora Resolution (#55)
    
    Handle new ref attribute. By Tanmai Khanna <khanna.tanmai@gmail.com>

diff --git a/apertium/transfer.cc b/apertium/transfer.cc
index 7941d94..f8950e3 100644
--- a/apertium/transfer.cc
+++ b/apertium/transfer.cc
@@ -313,6 +313,13 @@ Transfer::evalString(xmlNode *element)
         }
         break;
 
+      case ti_clip_ref:
+        if(checkIndex(element, ti.getPos(), lword))
+        {
+          return word[ti.getPos()]->reference(attr_items[ti.getContent()], ti.getCondition());
+        }
+        break;
+
       case ti_linkto_sl:
         if(checkIndex(element, ti.getPos(), lword))
         {
@@ -341,6 +348,20 @@ Transfer::evalString(xmlNode *element)
         }
         break;
 
+      case ti_linkto_ref:
+        if(checkIndex(element, ti.getPos(), lword))
+        {
+          if(word[ti.getPos()]->reference(attr_items[ti.getContent()], ti.getCondition()) != "")
+          {
+            return "<" + string((char *) ti.getPointer()) + ">";
+          }
+          else
+          {
+            return "";
+          }
+        }
+        break;
+
       case ti_var:
         return variables[ti.getContent()];
 
@@ -380,6 +401,13 @@ Transfer::evalString(xmlNode *element)
         }
         break;
 
+      case ti_case_of_ref:
+        if(checkIndex(element, ti.getPos(), lword))
+        {
+          return caseOf(word[ti.getPos()]->reference(attr_items[ti.getContent()]));
+        }
+        break;
+
       default:
         return "";
     }
@@ -425,6 +453,10 @@ Transfer::evalString(xmlNode *element)
       {
         evalStringCache[element] = TransferInstr(ti_linkto_sl, (const char *) part, pos, (void *) as, queue);
       }
+      else if(!xmlStrcmp(side, (const xmlChar *) "ref"))
+      {
+        evalStringCache[element] = TransferInstr(ti_linkto_ref, (const char *) part, pos, (void *) as, queue);
+      }
       else
       {
         evalStringCache[element] = TransferInstr(ti_linkto_tl, (const char *) part, pos, (void *) as, queue);
@@ -434,6 +466,10 @@ Transfer::evalString(xmlNode *element)
     {
       evalStringCache[element] = TransferInstr(ti_clip_sl, (const char *) part, pos, NULL, queue);
     }
+    else if(!xmlStrcmp(side, (const xmlChar *) "ref"))
+    {
+      evalStringCache[element] = TransferInstr(ti_clip_ref, (const char *) part, pos, NULL, queue);
+    }
     else
     {
       evalStringCache[element] = TransferInstr(ti_clip_tl, (const char *) part, pos, NULL, queue);
@@ -504,6 +540,10 @@ Transfer::evalString(xmlNode *element)
     {
       evalStringCache[element] = TransferInstr(ti_case_of_sl, (const char *) part, pos);
     }
+    else if(!xmlStrcmp(side, (const xmlChar *) "ref"))
+    {
+      evalStringCache[element] = TransferInstr(ti_case_of_ref, (const char *) part, pos);
+    }
     else
     {
       evalStringCache[element] = TransferInstr(ti_case_of_tl, (const char *) part, pos);
@@ -939,6 +979,12 @@ Transfer::processLet(xmlNode *localroot)
         }
         return;
 
+      case ti_clip_ref:
+        if (checkIndex(leftSide, ti.getPos(), lword)) {
+          word[ti.getPos()]->setReference(attr_items[ti.getContent()], evalString(rightSide), ti.getCondition());
+        }
+        return;
+
       default:
         return;
     }
@@ -996,6 +1042,11 @@ Transfer::processLet(xmlNode *localroot)
       word[pos]->setTarget(attr_items[(const char *) part], evalString(rightSide), queue);
       evalStringCache[leftSide] = TransferInstr(ti_clip_tl, (const char *) part, pos, NULL, queue);
     }
+    else if(!xmlStrcmp(side, (const xmlChar *) "ref"))
+    {
+      word[pos]->setReference(attr_items[(const char *) part], evalString(rightSide), queue);
+      evalStringCache[leftSide] = TransferInstr(ti_clip_ref, (const char *) part, pos, NULL, queue);
+    }
     else
     {
       word[pos]->setSource(attr_items[(const char *) part], evalString(rightSide), queue);
@@ -1086,6 +1137,12 @@ Transfer::processModifyCase(xmlNode *localroot)
 				      word[pos]->source(attr_items[(const char *) part], queue));
       word[pos]->setSource(attr_items[(const char *) part], result);
     }
+    else if(!xmlStrcmp(side, (const xmlChar *) "ref"))
+    {
+      string const result = copycase(evalString(rightSide),
+              word[pos]->reference(attr_items[(const char *) part], queue));
+      word[pos]->setReference(attr_items[(const char *) part], result);
+    }
     else
     {
       string const result = copycase(evalString(rightSide),
@@ -2036,6 +2093,8 @@ Transfer::transfer(FILE *in, FILE *out)
           {
             wstring sl;
             wstring tl;
+            wstring ref;
+
             int seenSlash = 0;
             for(wstring::const_iterator it = tmpword[0]->begin(); it != tmpword[0]->end(); it++)
             {
@@ -2047,17 +2106,25 @@ Transfer::transfer(FILE *in, FILE *out)
                   it++;
                   sl.push_back(*it);
                 }
-                else
+                else if(seenSlash == 1)
                 {
                   tl.push_back(*it);
                   it++;
                   tl.push_back(*it);
                 }
+                else
+                {
+                  ref.push_back(*it);
+                  it++;
+                  ref.push_back(*it);
+                }
                 continue;
               }
               else if(*it == L'/')
               {
                 seenSlash++;
+
+                ref.clear(); //the word after the last slash is the ref
                 continue;
               }
               if(seenSlash == 0)
@@ -2068,9 +2135,9 @@ Transfer::transfer(FILE *in, FILE *out)
               {
                 tl.push_back(*it);
               }
-              else if(seenSlash > 1)
+              else
               {
-                break;
+                ref.push_back(*it);
               }
             }
             //tmpword[0]->assign(sl);
@@ -2216,14 +2283,18 @@ Transfer::applyRule()
     if(useBilingual && preBilingual == false)
     {
       tr = fstp.biltransWithQueue(*tmpword[i], false);
+      wstring refx;
       word[i] = new TransferWord(UtfConverter::toUtf8(*tmpword[i]),
                                  UtfConverter::toUtf8(tr.first),
+                                 UtfConverter::toUtf8(refx),
                                  tr.second);
     }
     else if(preBilingual)
     {
       wstring sl;
       wstring tl;
+      wstring ref;
+
       int seenSlash = 0;
       for(wstring::const_iterator it = tmpword[i]->begin(); it != tmpword[i]->end(); it++)
       {
@@ -2235,18 +2306,26 @@ Transfer::applyRule()
             it++;
             sl.push_back(*it);
           }
-          else
+          else if(seenSlash == 1)
           {
             tl.push_back(*it);
             it++;
             tl.push_back(*it);
           }
+          else
+          {
+            ref.push_back(*it);
+            it++;
+            ref.push_back(*it);
+          }
           continue;
         }
 
         if(*it == L'/')
         {
           seenSlash++;
+
+          ref.clear(); //word after last slash is ref
           continue;
         }
         if(seenSlash == 0)
@@ -2257,21 +2336,24 @@ Transfer::applyRule()
         {
           tl.push_back(*it);
         }
-        else if(seenSlash > 1)
+        else
         {
-          break;
+          ref.push_back(*it);
         }
       }
       tr = pair<wstring, int>(tl, false);
       word[i] = new TransferWord(UtfConverter::toUtf8(sl),
                                  UtfConverter::toUtf8(tr.first),
+                                 UtfConverter::toUtf8(ref),
                                  tr.second);
     }
     else // neither useBilingual nor preBilingual (sl==tl)
     {
       tr = pair<wstring, int>(*tmpword[i], false);
+      wstring refx;
       word[i] = new TransferWord(UtfConverter::toUtf8(*tmpword[i]),
                                  UtfConverter::toUtf8(tr.first),
+                                 UtfConverter::toUtf8(refx), 
                                  tr.second);
     }
   }
diff --git a/apertium/transfer.dtd b/apertium/transfer.dtd
index 3107d08..48b93d2 100644
--- a/apertium/transfer.dtd
+++ b/apertium/transfer.dtd
@@ -364,7 +364,7 @@ representing a lexical form in the matched pattern
 
 <!ELEMENT clip EMPTY>
 <!ATTLIST clip pos CDATA #REQUIRED
-               side (sl|tl) #REQUIRED
+               side (sl|tl|ref) #REQUIRED
                part CDATA #REQUIRED
                queue CDATA #IMPLIED
                link-to CDATA #IMPLIED
@@ -377,7 +377,7 @@ representing a lexical form in the matched pattern
          inside the rule;
 
       * 'side' is used to select a source-language ('sl') or a
-        target-language ('tl') clip
+        target-language ('tl') or the reference ('ref') clip
 
       * the value of 'part' is the name of an attribute defined in
         def-attrs, but may take also the values 'lem' (referring to
diff --git a/apertium/transfer_instr.h b/apertium/transfer_instr.h
index 795856e..a16e31c 100644
--- a/apertium/transfer_instr.h
+++ b/apertium/transfer_instr.h
@@ -25,6 +25,7 @@ enum TransferInstrType
 {
   ti_clip_sl,
   ti_clip_tl,
+  ti_clip_ref,
   ti_var,
   ti_lit_tag,
   ti_lit,
@@ -32,8 +33,10 @@ enum TransferInstrType
   ti_get_case_from,
   ti_case_of_sl,
   ti_case_of_tl,
+  ti_case_of_ref,
   ti_linkto_sl,
   ti_linkto_tl,
+  ti_linkto_ref,
   ti_lu_count
 };
 
diff --git a/apertium/transfer_word.cc b/apertium/transfer_word.cc
index b96592a..289a8e0 100644
--- a/apertium/transfer_word.cc
+++ b/apertium/transfer_word.cc
@@ -25,6 +25,7 @@ TransferWord::copy(TransferWord const &o)
 {
   s_str = o.s_str;
   t_str = o.t_str;
+  r_str = o.r_str;
   queue_length = o.queue_length;
 }
 
@@ -38,9 +39,9 @@ queue_length(0)
 {
 }
 
-TransferWord::TransferWord(string const &src, string const &tgt, int queue)
+TransferWord::TransferWord(string const &src, string const &tgt, string const &ref, int queue)
 {
-  init(src, tgt);
+  init(src, tgt, ref);
   queue_length = queue;
 }
 
@@ -66,10 +67,11 @@ TransferWord::operator =(TransferWord const &o)
 }
 
 void
-TransferWord::init(string const &src, string const &tgt)
+TransferWord::init(string const &src, string const &tgt, string const &ref)
 {
   s_str = src;
   t_str = tgt;
+  r_str = ref;
 }
 
 string
@@ -98,6 +100,19 @@ TransferWord::target(ApertiumRE const &part, bool with_queue)
   }
 }
 
+string
+TransferWord::reference(ApertiumRE const &part, bool with_queue)
+{
+  if(with_queue)
+  {
+    return part.match(r_str);
+  }
+  else
+  {
+    return part.match(r_str.substr(0, r_str.size() - queue_length));
+  }
+}
+
 void
 TransferWord::setSource(ApertiumRE const &part, string const &value,
 			bool with_queue)
@@ -129,3 +144,19 @@ TransferWord::setTarget(ApertiumRE const &part, string const &value,
     t_str = mystring + t_str.substr(t_str.size() - queue_length);
   }
 }
+
+void
+TransferWord::setReference(ApertiumRE const &part, string const &value,
+      bool with_queue)
+{
+  if(with_queue)
+  {
+    part.replace(r_str, value);
+  }
+  else
+  {
+    string mystring = r_str.substr(0, r_str.size() - queue_length);
+    part.replace(mystring, value);
+    r_str = mystring + r_str.substr(r_str.size() - queue_length);
+  }
+}
diff --git a/apertium/transfer_word.h b/apertium/transfer_word.h
index bc67f8d..b00fb61 100644
--- a/apertium/transfer_word.h
+++ b/apertium/transfer_word.h
@@ -41,6 +41,11 @@ private:
    */
   string t_str;
 
+  /**
+   * Reference word
+   */
+  string r_str;
+
   /**
    * Queue length
    */
@@ -58,17 +63,17 @@ private:
   void destroy();
 
   /**
-   * Accesses the source/target side of a word using the specified part
-   * @param str tipically s_str or t_str
+   * Accesses the source/target/reference side of a word using the specified part
+   * @param str typically s_str or t_str or r_str
    * @param part regular expression to match/access
    * @return reference to matched/accessed string
    */
   string access(string const &str, ApertiumRE const &part);
 
   /**
-   * Assings a value to the source/target side of a word using the
+   * Assings a value to the source/target/reference side of a word using the
    * specified part
-   * @param str tipically s_str or t_str
+   * @param str typically s_str or t_str or r_str
    * @param part regular expression to match/access
    * @param value the string to be assigned
    */
@@ -94,9 +99,10 @@ public:
    * Parametric constructor calling init()
    * @param src source word
    * @param tgt target word
+   * @param ref reference word
    * @param queue queue lenght
    */
-  TransferWord(string const &src, string const &tgt, int queue = 0);
+  TransferWord(string const &src, string const &tgt, string const &ref, int queue = 0);
 
   /**
    * Assignment operator
@@ -106,12 +112,13 @@ public:
   TransferWord & operator =(TransferWord const &o);
 
   /**
-   * Sets a bi-word (a source language word and its counterpart in target
-   * language
+   * Sets a tri-word (a source language word, its counterpart in target
+   * language, and a reference if one exists
    * @param src source word
    * @param tgt target word
+   * @param ref reference word
    */
-  void init(string const &src, string const &tgt);
+  void init(string const &src, string const &tgt, string const &ref);
 
   /**
    * Reference a source language word part
@@ -129,6 +136,14 @@ public:
    */
   string target(ApertiumRE const &part, bool with_queue = true);
 
+  /**
+   * Reference the reference word part
+   * @param part regular expression to match
+   * @param with_queue access taking into account the queue
+   * @returns reference to the part of string matched
+   */
+  string reference(ApertiumRE const &part, bool with_queue = true);
+
   /**
    * Sets a value for a source language word part
    * @param part regular expression to match
@@ -146,6 +161,15 @@ public:
    */
   void setTarget(ApertiumRE const &part, string const &value,
 		 bool with_queue = true);
+
+  /**
+   * Sets a value for a reference word part
+   * @param part regular expression to match
+   * @param value the new value for the given part
+   * @param with_queue access taking or not into account the queue
+   */
+  void setReference(ApertiumRE const &part, string const &value,
+     bool with_queue = true);
 };
 
 #endif