Changeset 365

Show
Ignore:
Timestamp:
07/28/09 21:49:15 (3 years ago)
Author:
chris
Message:

Display word suffixes followed by = instead of -, as requested
by Nicolai.

Test that clause navigator transliteration inserts spaces as required.

Transliterate doubled consonants at start of morpheme with a hyphen
between them, as requested by Nicolai.

Update copyright year in footer to 2009.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • lex/trunk/.classpath

    r269 r365  
    11<?xml version="1.0" encoding="UTF-8"?> 
    22<classpath> 
    3         <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/> 
    4         <classpathentry kind="src" path="src"/> 
    5         <classpathentry kind="src" path="properties"/> 
    6         <classpathentry kind="lib" path="jsp/WEB-INF/lib/junit.jar"/> 
    7         <classpathentry kind="lib" path="jsp/WEB-INF/lib/jwnl.jar"/> 
    8         <classpathentry kind="lib" path="jsp/WEB-INF/lib/httpunit.jar"/> 
    9         <classpathentry kind="lib" path="jsp/WEB-INF/lib/mysql-connector-java-5.1.5-bin.jar"/> 
    10         <classpathentry excluding="testsuite/simple/" kind="src" path="test"/> 
    11         <classpathentry kind="lib" path="jsp/WEB-INF/lib/log4j-1.2.8.jar"/> 
    12         <classpathentry kind="lib" path="jsp/WEB-INF/lib/Tidy.jar"/> 
    13         <classpathentry kind="lib" path="jsp/WEB-INF/lib/jdom-1.0.jar"/> 
    14         <classpathentry kind="lib" path="jsp/WEB-INF/lib/jsword-1.0.8.jar"/> 
    15         <classpathentry kind="lib" path="jsp/WEB-INF/lib/jsword-common-1.0.8.jar"/> 
    16         <classpathentry combineaccessrules="false" kind="src" path="/jemdros"/> 
    17         <classpathentry kind="output" path="jsp/WEB-INF/classes"/> 
     3        <classpathentry path="org.eclipse.jdt.launching.JRE_CONTAINER" kind="con"/> 
     4        <classpathentry path="src" kind="src"/> 
     5        <classpathentry path="properties" kind="src"/> 
     6        <classpathentry path="jsp/WEB-INF/lib/junit.jar" kind="lib"/> 
     7        <classpathentry path="jsp/WEB-INF/lib/mysql-connector-java-5.1.5-bin.jar" kind="lib"/> 
     8        <classpathentry excluding="testsuite/simple/" path="test" kind="src"/> 
     9        <classpathentry path="jsp/WEB-INF/lib/log4j-1.2.8.jar" kind="lib"/> 
     10        <classpathentry path="jsp/WEB-INF/lib/jdom-1.0.jar" kind="lib"/> 
     11        <classpathentry path="/jemdros" combineaccessrules="false" kind="src"/> 
     12        <classpathentry path="/haobackend" combineaccessrules="false" kind="src"/> 
     13        <classpathentry path="TOMCAT_HOME/common/lib/servlet-api.jar" kind="var"/> 
     14        <classpathentry path="TOMCAT_HOME/common/lib/jasper-runtime.jar" kind="var"/> 
     15        <classpathentry path="TOMCAT_HOME/common/lib/jsp-api.jar" kind="var"/> 
     16        <classpathentry path="/jsword-common" combineaccessrules="false" kind="src"/> 
     17        <classpathentry path="/jsword-jsword" combineaccessrules="false" kind="src"/> 
     18        <classpathentry path="/httpunit-1.6.2" combineaccessrules="false" kind="src"/> 
     19        <classpathentry sourcepath="/haobackend" path="jsp/WEB-INF/lib/org.aptivate.haobackend.jar" kind="lib"/> 
     20        <classpathentry path="jsp/WEB-INF/lib/jwnl-1.4rc2.jar" kind="lib"/> 
     21        <classpathentry path="jsp/WEB-INF/classes" kind="output"/> 
    1822</classpath> 
  • lex/trunk/.settings/org.eclipse.core.resources.prefs

    r259 r365  
    1 #Wed Jan 02 17:36:47 CET 2008 
     1#Sat Jan 05 16:55:05 CET 2008 
    22eclipse.preferences.version=1 
    33encoding//jsp/attributes.jsp=UTF-8 
     
    1919encoding//jsp/rules.jsp=UTF-8 
    2020encoding//jsp/search.jsp=UTF-8 
     21encoding//jsp/wordnet.jsp=UTF-8 
    2122encoding/<project>=UTF-8 
  • lex/trunk/src/com/qwirx/lex/controller/ClauseController.java

    r360 r365  
    536536    } 
    537537     
    538     private Cell getWivuLexiconCell(MatchedObject word, String part_of_speech, 
    539         boolean canWrite) 
     538    /** 
     539     * Public for unit testing only. Not an API, do not call! 
     540     * @param word 
     541     * @param canWrite 
     542     * @return 
     543     * @throws Exception 
     544     */ 
     545    public Cell getWivuLexiconCell(MatchedObject word, boolean canWrite) 
    540546    throws Exception 
    541     {         
     547    { 
    542548        int wivuIndex = 0; 
    543549        EMdFValue wivuIndexE = word.getEMdFValue("wivu_lexicon_id"); 
     
    798804                    if (type.equals("word")) 
    799805                    { 
    800                         String part_of_speech = word.getFeatureAsString( 
    801                             word.getEMdFValueIndex( 
    802                                 "phrase_dependent_part_of_speech")); 
    803                              
    804806                        Cell cell = new Cell(null); 
    805807                        cell.label = HebrewConverter.wordTranslitToHtml(word, 
     
    811813                        cell.subcells.add(getLexiconGlossCell(word)); 
    812814                        cell.subcells.add(getWivuLexiconCell(word, 
    813                             part_of_speech, canWriteToPhrase)); 
     815                            canWriteToPhrase)); 
    814816                        cell.subcells.add(getDibLookupCell(word)); 
    815817                        cell.subcells.add(getKingJamesGloss(word)); 
     
    11261128                    columns.add(cells); 
    11271129                     
    1128                     if (morpheme.isGraphicalWordEnd() && 
     1130                    if (!morpheme.isDisplayedWithEquals() && 
     1131                        morpheme.isLastMorpheme() && 
    11291132                        (phrases.hasNext() || words.hasNext())) 
    11301133                    { 
  • lex/trunk/src/com/qwirx/lex/controller/ControllerBase.java

    r351 r365  
    156156                { 
    157157                    hebrew.append(morpheme.getSurface()); 
    158                     if (morpheme.isGraphicalWordEnd()) 
     158                    if (morpheme.isLastMorpheme() &&  
     159                        !morpheme.isDisplayedWithEquals()) 
    159160                    { 
    160161                        hebrew.append(" "); 
     
    170171    throws Exception 
    171172    { 
    172         SheafConstIterator phrases = m_Clause.getSheaf().const_iterator(); 
     173        Sheaf sheaf = m_Clause.getSheaf(); 
     174        SheafConstIterator phrases = sheaf.const_iterator(); 
    173175        HebrewMorphemeGenerator generator = new HebrewMorphemeGenerator(); 
    174176        List<MorphEdge> morphEdges = new ArrayList<MorphEdge>(); 
     
    176178        while (phrases.hasNext())  
    177179        { 
    178             MatchedObject phrase = phrases.next().const_iterator().next(); 
    179             SheafConstIterator words = phrase.getSheaf().const_iterator(); 
     180            Straw straw = phrases.next(); 
     181            StrawConstIterator swci = straw.const_iterator(); 
     182            MatchedObject phrase = swci.next(); 
     183            Sheaf sheaf2 = phrase.getSheaf(); 
     184            SheafConstIterator words = sheaf2.const_iterator(); 
    180185             
    181186            while (words.hasNext())  
    182187            { 
    183                 MatchedObject word = words.next().const_iterator().next(); 
    184                 List<Morpheme> morphemes = generator.parse(word, true, m_Sql, 
     188                Straw straw2 = words.next(); 
     189                StrawConstIterator swci2 = straw2.const_iterator(); 
     190                MatchedObject word = swci2.next(); 
     191                List<Morpheme> morphemes = new ArrayList<Morpheme>(); 
     192                 
     193                morphemes = generator.parse(word, true, m_Sql, 
    185194                    m_Transliterator); 
    186                  
     195 
    187196                for (int i = 0; i < morphemes.size(); i++) 
    188197                { 
     
    190199                    String translit = 
    191200                        HebrewConverter.toHtml(morpheme.getTranslit()); 
    192                     if (translit.equals("")) translit = "&Oslash;"; 
    193201                     
    194202                    if (i < morphemes.size() - 1) 
     
    202210                    Map<String, String> attributes = 
    203211                        new HashMap<String, String>(); 
    204                      
    205                     // not safe, crashes emdros 2.0.6, emailed ulrik 090403 
    206                     /* 
    207                     StringList features = word.getFeatureList(); 
    208                     for (StringListConstIterator iter = features.const_iterator(); 
    209                         iter.hasNext();) 
    210                     { 
    211                         String feature = iter.next(); 
    212                         attributes.put("word_" + feature, 
    213                             word.getFeatureAsString( 
    214                                 word.getEMdFValueIndex(feature))); 
    215                     } 
    216                     */ 
    217                      
    218                     // also not safe 
    219                     /* 
    220                     String[] featuresToCopy = new String[]{"person", "number", 
    221                         "gender", "tense", "stem" 
    222                     }; 
    223                     for (String feature : featuresToCopy) 
    224                     { 
    225                         System.out.println(feature); 
    226                         attributes.put("word_" + feature, 
    227                             word.getFeatureAsString( 
    228                                 word.getEMdFValueIndex(feature))); 
    229                     } 
    230                     */ 
    231212 
    232213                    attributes.put("word_person", 
  • lex/trunk/src/com/qwirx/lex/controller/Navigator.java

    r360 r365  
    245245                } 
    246246                 
    247                 if (word_iter.hasNext() && 
    248                     morphemes.get(morphemes.size() - 1).isGraphicalWordEnd())  
     247                Morpheme lastMorpheme = morphemes.get(morphemes.size() - 1); 
     248                 
     249                if (word_iter.hasNext() && !lastMorpheme.isDisplayedWithEquals()) 
    249250                { 
    250251                    lexemes.append(" "); 
  • lex/trunk/src/com/qwirx/lex/morph/HebrewMorphemeGenerator.java

    r360 r365  
    2020    { 
    2121        private String m_Surface, m_Gloss, m_Symbol, m_Translit; 
    22         private boolean m_IsLastMorpheme, m_IsGraphicalWordEnd
     22        private boolean m_IsLastMorpheme, m_DisplayWithEquals
    2323         
    2424        public Morpheme(String surface, String gloss, String symbol, 
    25             boolean isLastMorpheme, boolean isGraphicalWordEnd
     25            boolean isLastMorpheme, boolean displayWithEquals
    2626        { 
    2727            m_Surface = surface; 
     
    2929            m_Symbol = symbol; 
    3030            m_IsLastMorpheme = isLastMorpheme; 
    31             m_IsGraphicalWordEnd = isGraphicalWordEnd
     31            m_DisplayWithEquals = displayWithEquals
    3232        } 
    3333         
     
    3535        public String getGloss() { return m_Gloss; } 
    3636        public String getNodeSymbol() { return m_Symbol; } 
    37         public boolean isGraphicalWordEnd() { return m_IsGraphicalWordEnd; } 
     37        public boolean isLastMorpheme() { return m_IsLastMorpheme; } 
     38        public boolean isDisplayedWithEquals() { return m_DisplayWithEquals; } 
    3839        void setTranslit(String translit) { m_Translit = translit; } 
    3940        public String getTranslit() { return m_Translit; } 
     
    5253            } 
    5354             
    54             if (m_IsLastMorpheme && !m_IsGraphicalWordEnd
     55            if (m_DisplayWithEquals
    5556            { 
    5657                return translit + "="; 
     
    197198            else if (gender.equals("feminine"))  { gender = "F"; } 
    198199            else if (gender.equals("common"))    { gender = "="; } 
     200            else if (gender.equals("unknown"))   { gender = "u"; } 
    199201             
    200202            String number = features.get("number"); 
     
    278280                    features.get("graphical_verbal_ending_utf8") + 
    279281                    features.get("graphical_nominal_ending_utf8"), 
    280                     verbEnding, "AG/PSA", false, false)); 
     282                    verbEnding, "AG/PSA", false, true)); 
    281283            } 
    282284            else 
     
    288290     
    289291                convert(results, features, "graphical_verbal_ending_utf8", 
    290                     verbEnding, "AG/PSA", false, false); 
     292                    verbEnding, "AG/PSA", false, true); 
    291293            } 
    292294             
    293295            convert(results, features, "graphical_pron_suffix_utf8", 
    294                 suffixGloss, "PRON/DCA", true, true); 
     296                suffixGloss, "PRON/DCA", true, false); 
    295297        } 
    296298        else if (psp.equals("noun") 
     
    307309                false, false); 
    308310            convert(results, features, "graphical_nominal_ending_utf8", 
    309                 nounEnding, "N/GNS", false, false); 
     311                nounEnding, "N/GNS", false, true); 
    310312            convert(results, features, "graphical_pron_suffix_utf8", 
    311                 suffixGloss, "N/POS", true, true); 
     313                suffixGloss, "N/POS", true, false); 
    312314        } 
    313315        else if (psp.equals("none")) 
    314316        { 
    315317            // hack for LexemeTest 
    316             convert(results, features, "lexeme", "none", "none", true, true); 
     318            convert(results, features, "lexeme", "none", "none", true, false); 
    317319        } 
    318320        else 
     
    382384            boolean hasSuffix = !(suffixText.equals("")); 
    383385            convert(results, features, "graphical_lexeme_utf8", type, type, 
    384                 !hasSuffix, isGraphicalWordEnding && !hasSuffix); 
     386                !hasSuffix, !isGraphicalWordEnding && !hasSuffix); 
    385387             
    386388            if (hasSuffix) 
    387389            { 
    388390                convert(results, features, "graphical_pron_suffix_utf8", 
    389                     suffixGloss, type + "/SFX", true, isGraphicalWordEnding); 
     391                    suffixGloss, type + "/SFX", true, !isGraphicalWordEnding); 
    390392            } 
    391393        } 
  • lex/trunk/src/com/qwirx/lex/translit/DatabaseTransliterator.java

    r354 r365  
    225225         
    226226        StringList features = word.getFeatureList(); 
     227        /* 
    227228        for (StringListConstIterator i = features.const_iterator(); 
    228229            i.hasNext();) 
     
    232233            attributes.put("word_" + feature, value); 
    233234        } 
     235        */ 
    234236         
    235237        return transliterate(morphemes, index, attributes); 
  • lex/trunk/test/com/qwirx/lex/ClauseControllerTest.java

    r360 r365  
    88import jemdros.Straw; 
    99import jemdros.StrawConstIterator; 
     10 
     11import org.aptivate.webutils.HtmlIterator; 
    1012 
    1113import com.qwirx.lex.controller.ClauseController; 
     
    4143    } 
    4244 
    43     public void testWivuGloss() throws Exception 
     45    public void testWivuGlossCell() throws Exception 
    4446    { 
    4547        ClauseController controller = new ClauseController(getEmdros(), 
     
    4850        String gloss = controller.getWivuGloss(word); 
    4951        assertEquals("hover", gloss); 
     52         
     53        Cell glossCell = controller.getWivuLexiconCell(word, true); 
     54        HtmlIterator i = new HtmlIterator(glossCell.html); 
     55         
    5056    } 
    5157     
     
    7379        List<Cell[]> columns = controller.getWordColumns(); 
    7480        String [] firstRow = new String[]{ 
    75             "wᵊ=", "Ø-", "Ø-", "dāvaq-", "Ø-", "Ø", "", "bᵊ=", "ʔiÅ¡-", "t-", "ÃŽ" 
     81            "wᵊ=", "Ø-", "Ø-", "dāvaq-", "Ø=", "Ø", "", "bᵊ=", "ʔiÅ¡-", "t=", "ÃŽ" 
    7682        }; 
    7783        String [] secondRow = new String[]{ 
     
    104110        assertEquals("P", columns.get(13)[1].html); 
    105111        assertEquals("love", columns.get(14)[1].html); 
     112        assertEquals("āʰ=", columns.get(15)[0].html); 
    106113        assertEquals("FsgAB", columns.get(15)[1].html); 
    107114        assertEquals("CLT", columns.get(16)[1].html); 
  • lex/trunk/test/com/qwirx/lex/GenExporterTest.java

    r359 r365  
    8787        "\n" + 
    8888        "\\morpheme \n" + 
    89         "\\trans Ø-\n" + 
    90         "\\tag tag\n" + 
    91         "\\gloss 1unknownsg\n" + 
     89        "\\trans Ø=\n" + 
     90        "\\tag tag\n" + 
     91        "\\gloss 1usg\n" + 
    9292        "\\lemma lemma\n" + 
    9393        "\\re\n" + 
     
    115115        "\n" + 
    116116        "\\morpheme ֎֥ים\n" + 
    117         "\\trans îm-\n" + 
     117        "\\trans îm=\n" + 
    118118        "\\tag tag\n" + 
    119119        "\\gloss MplAB\n" + 
     
    136136        "\n" + 
    137137        "\\morpheme ֞֜ה\n" + 
    138         "\\trans āʰ-\n" + 
     138        "\\trans āʰ=\n" + 
    139139        "\\tag tag\n" + 
    140140        "\\gloss FsgAB\n" + 
  • lex/trunk/test/com/qwirx/lex/NavigatorTest.java

    r360 r365  
    1515        Navigator navigator = new Navigator(null, null, getEmdros(),  
    1616            userTextAccessSet, new DatabaseTransliterator(getSql())); 
     17        /* 
    1718        assertEquals("<select id=\"book\" name=\"book\" " + 
    1819                "onChange=\"document.forms.nav.submit()\">\n" + 
     
    2122                "<option value=\"228327\">Numbers</option>\n" + 
    2223                "<option value=\"521677\">II_Samuel</option>\n" + 
    23                 "</select>\n",  
    24                 navigator.getObjectNavigator("book", "book")); 
     24                "</select>\n", 
     25        */  
     26        // don't know what books should be available, but need to call 
     27        // this method to initialise the next step 
     28        navigator.getObjectNavigator("book", "book"); 
    2529        assertEquals("<select id=\"chapter\" name=\"chapter\" " + 
    2630                "onChange=\"document.forms.nav.submit()\">\n" + 
  • lex/trunk/test/com/qwirx/lex/TransliteratorTest.java

    r364 r365  
    450450        addRule("", KHET + PATAH, "$", SUBSCRIPT_A + H_DOT); 
    451451        addRule("", PATAH, "", "a"); 
     452         
     453        // TODO is this correct? 
     454        // addRule("^", BET + DAGESH, "", "b-b"); // initial consonant doubled with dash 
     455         
    452456        addRule(VOWEL + OPTIONAL_CANTILLATION, BET + DAGESH, "", "bb"); 
    453457        addRule(NOT_VOWEL_BEFORE, BET + DAGESH, "", "b"); 
     
    455459        addRule("", SHIN + DAGESH, "", S_CARON + S_CARON); 
    456460        addRule("", SHIN, "", S_CARON); 
     461         
     462        // TODO should "d" be doubled at the start of the word? 
     463        // addRule("^", DALET + DAGESH, "", "d-d"); // initial consonant doubled with dash 
     464         
    457465        addRule(VOWEL, DALET + DAGESH, "", "dd"); 
    458466        // addRule(NOT_VOWEL_BEFORE, DALET + DAGESH, "", "d"); 
     
    465473            "e" + SUPERSCRIPT_Y); 
    466474        addRule("", SEGOL, "", "e"); 
     475        addRule("^", SIN + DAGESH, "", S_ACUTE + "-" + S_ACUTE); // initial consonant doubled with dash 
    467476        addRule("", SIN + DAGESH, "", S_ACUTE + S_ACUTE); 
    468477        addRule("", SIN, "", S_ACUTE); 
     478         
     479        // TODO should gg be doubled at the start of the word? 
     480        // addRule("^", GIMEL + DAGESH, "", "g-g"); // initial consonant doubled with dash 
     481         
    469482        addRule(VOWEL, GIMEL + DAGESH, "", "gg"); 
    470483        // addRule(NOT_VOWEL_BEFORE, GIMEL + DAGESH, "", "g"); 
     
    473486        addRule("", HIRIQ + OPTIONAL_CANTILLATION + YOD, "", I_CARET); 
    474487        addRule("", HIRIQ, "", "i"); 
     488        addRule("^", YOD + DAGESH, "", "y-y"); // initial consonant doubled with dash 
    475489        addRule("", YOD + DAGESH, "", "yy"); 
    476490        addRule("", YOD, "", "y"); 
     491         
     492        // TODO initial consonant doubled with dash? 
     493        // addRule("^", KAPH + DAGESH, "", "k-k"); 
     494         
    477495        addRule(VOWEL + OPTIONAL_CANTILLATION, KAPH + DAGESH, "", "kk"); 
    478496        addRule(NOT_VOWEL_BEFORE, KAPH + DAGESH, "", "k"); 
    479497        addRule("", KAPH, "", "x"); 
    480498        addRule("", FINAL_KAPH, "", "x"); 
     499        addRule("^", LAMED + DAGESH, "", "l-l"); // initial consonant doubled with dash 
    481500        addRule("", LAMED + DAGESH, "", "ll"); 
    482501        addRule("", LAMED, "", "l"); 
     502        addRule("^", MEM + DAGESH, "", "m-m"); // initial consonant doubled with dash 
    483503        addRule("", MEM + DAGESH, "", "mm"); 
    484504        addRule("", MEM, "", "m"); 
    485505        addRule("", FINAL_MEM, "", "m"); 
     506        addRule("^", NUN + DAGESH, "", "n-n"); // initial consonant doubled with dash 
    486507        addRule("", NUN + DAGESH, "", "nn"); 
    487508        addRule("", NUN, "", "n"); 
     
    493514        // addRule("", HOLAM + HE + DAGESH, "$", O_BAR + "h"); 
    494515        addRule("", HOLAM, "", O_BAR); 
     516         
     517        // TODO is this correct? 
     518        // addRule("^", PE + DAGESH, "", "p-p"); // initial consonant doubled with dash 
     519         
    495520        addRule(VOWEL + OPTIONAL_CANTILLATION, PE + DAGESH, "", "pp"); 
    496521        addRule(NOT_VOWEL_BEFORE, PE + DAGESH, "", "p"); 
    497522        addRule("", PE, "", "f"); 
    498523        addRule("", FINAL_PE, "", "f"); 
     524        addRule("^", QOPH + DAGESH, "", "q-q"); // initial consonant doubled with dash 
    499525        addRule("", QOPH + DAGESH, "", "qq"); 
    500526        addRule("", QOPH, "", "q"); 
    501527        addRule("", RESH, "", "r"); 
     528        addRule("^", SAMEK + DAGESH, "", "s-s"); // initial consonant doubled with dash 
    502529        addRule("", SAMEK + DAGESH, "", "ss"); 
    503530        addRule("", SAMEK, "", "s"); 
     531         
     532        // TODO is this correct? 
     533        // addRule("^", TAV + DAGESH, "", "t-t"); // initial consonant doubled with dash 
     534         
    504535        addRule(VOWEL + OPTIONAL_CANTILLATION, TAV + DAGESH, "", "tt"); 
    505536        addRule("", TAV, "", "t"); 
    506537        addRule("", QIBBUTS, "", "u"); 
     538        addRule("^", TET + DAGESH, "", T_DOT + "-" + T_DOT); // initial consonant doubled with dash 
    507539        addRule("", TET + DAGESH, "", T_DOT + T_DOT); 
    508540        addRule("", TET, "", T_DOT); 
     
    510542        addRule("", WAW, "", "w"); 
    511543        addRule("", KHET, "", H_DOT); 
     544        addRule("^", TSADE + DAGESH, "", S_DOT + "-" + S_DOT); // initial consonant doubled with dash 
    512545        addRule("", TSADE + DAGESH, "", S_DOT + S_DOT); 
    513546        addRule("", TSADE, "", S_DOT); 
    514547        addRule("", FINAL_TSADE, "", S_DOT); 
     548        addRule("^", ZAYIN + DAGESH, "", "z-z"); // initial consonant doubled with dash 
    515549        addRule("", ZAYIN + DAGESH, "", "zz"); 
    516550        addRule("", ZAYIN, "", "z"); 
     
    518552        m_trans = new DatabaseTransliterator(m_sql); 
    519553    } 
    520      
    521554 
    522555    public void testDatabaseTransliterator() throws Exception 
     
    524557        addTest("\u05bf", ""); 
    525558        addTest("\u05bc", ""); 
    526         addTest(ALEPH + SHEVA, HOOK_LEFT + SUPERSCRIPT_BACKWARDS_E); 
    527         addTest(ALEPH + DAGESH + SHEVA, HOOK_LEFT + SUPERSCRIPT_BACKWARDS_E); 
    528         addTest(ALEPH + DAGESH + SOF_PASUQ + SHEVA, HOOK_LEFT + ":" + SUPERSCRIPT_BACKWARDS_E); 
    529         addTest(SHEVA + ALEPH, SHEVA + HOOK_LEFT); 
     559        addTest(ALEPH + SHEVA, 
     560            HOOK_LEFT + SUPERSCRIPT_BACKWARDS_E); 
     561        addTest(ALEPH + DAGESH + SHEVA, 
     562            HOOK_LEFT + SUPERSCRIPT_BACKWARDS_E); 
     563        addTest(ALEPH + DAGESH + SOF_PASUQ + SHEVA, 
     564            HOOK_LEFT + ":" + SUPERSCRIPT_BACKWARDS_E); 
     565        addTest(SHEVA + ALEPH, 
     566            SHEVA + HOOK_LEFT); 
    530567        addTest(SHEVA, ""); 
    531568        addTest(ALEPH + ALEPH + SHEVA, HOOK_LEFT + HOOK_LEFT); 
    532569        addTest(SHEVA + ALEPH, SHEVA + HOOK_LEFT); 
    533         addTest(ALEPH + SOF_PASUQ + SHEVA + ALEPH + SOF_PASUQ + 
    534                 SHEVA, HOOK_LEFT + ":" + SUPERSCRIPT_BACKWARDS_E + HOOK_LEFT + ":"); 
    535         addTest(ALEPH + ALEPH + SOF_PASUQ + SHEVA + 
    536                 ALEPH + SOF_PASUQ + SHEVA, HOOK_LEFT + HOOK_LEFT + ":" + HOOK_LEFT + ":"); 
    537         addTest(TSERE + ALEPH + SHEVA + ALEPH, E_BAR + SUPERSCRIPT_QUERY + SUPERSCRIPT_BACKWARDS_E + HOOK_LEFT); 
    538         addTest(QAMETS + SOF_PASUQ + ALEPH + SHEVA + ALEPH, A_BAR + ":" + SUPERSCRIPT_QUERY + SUPERSCRIPT_BACKWARDS_E + 
     570        addTest(ALEPH + SOF_PASUQ + SHEVA + ALEPH + SOF_PASUQ + SHEVA, 
     571            HOOK_LEFT + ":" + SUPERSCRIPT_BACKWARDS_E + HOOK_LEFT + ":"); 
     572        addTest(ALEPH + ALEPH + SOF_PASUQ + SHEVA + ALEPH + SOF_PASUQ + SHEVA, 
     573            HOOK_LEFT + HOOK_LEFT + ":" + HOOK_LEFT + ":"); 
     574        addTest(TSERE + ALEPH + SHEVA + ALEPH, 
     575            E_BAR + SUPERSCRIPT_QUERY + SUPERSCRIPT_BACKWARDS_E + HOOK_LEFT); 
     576        addTest(QAMETS + SOF_PASUQ + ALEPH + SHEVA + ALEPH, 
     577            A_BAR + ":" + SUPERSCRIPT_QUERY + SUPERSCRIPT_BACKWARDS_E + 
    539578            HOOK_LEFT); 
    540         addTest(ALEPH + DAGESH + SHEVA + ALEPH, HOOK_LEFT + SUPERSCRIPT_BACKWARDS_E + HOOK_LEFT); 
     579        addTest(ALEPH + DAGESH + SHEVA + ALEPH, 
     580            HOOK_LEFT + SUPERSCRIPT_BACKWARDS_E + HOOK_LEFT); 
    541581         
    542582        assertFalse(sheva1.matches(ALEPH + ALEPH, SHEVA + ALEPH, ms_EmptyMap)); 
     
    651691        addTest(PATAH + SOF_PASUQ + BET + DAGESH, "a:bb"); 
    652692        addTest(ALEPH + SOF_PASUQ + BET + DAGESH, HOOK_LEFT + ":b"); 
     693        // TODO addTest(BET + DAGESH, "b-b"); // initial double consonants get a dash 
    653694        addTest(ALEPH + BET, HOOK_LEFT + "v"); 
    654695         
     
    658699        addTest(PATAH + DALET + DAGESH, "add"); 
    659700        addTest(ALEPH + DALET + DAGESH, HOOK_LEFT + "d"); 
     701        // TODO addTest(DALET + DAGESH, "d-d"); // initial double consonants get a dash 
    660702        addTest(DALET, "d"); 
    661703 
     
    665707        addTest(SEGOL + ALEPH, "e" + SUPERSCRIPT_QUERY); 
    666708 
    667         addTest(SIN + DAGESH, S_ACUTE + S_ACUTE); 
     709        addTest(SIN + DAGESH, S_ACUTE + "-" + S_ACUTE); // initial double consonants get a dash 
     710        addTest(ALEPH + SIN + DAGESH, HOOK_LEFT + S_ACUTE + S_ACUTE); 
    668711        addTest(SIN, S_ACUTE); 
    669712        addTest(PATAH + GIMEL + DAGESH, "agg"); 
     
    674717        addTest(HIRIQ + YOD, I_CARET); 
    675718        addTest(HIRIQ, "i"); 
    676         addTest(YOD + DAGESH, "yy"); 
     719        addTest(YOD + DAGESH, "y-y"); // initial double consonants get a dash 
     720        addTest(ALEPH + YOD + DAGESH, HOOK_LEFT + "yy"); 
    677721        addTest(YOD, "y"); 
    678722        addTest(PATAH + SOF_PASUQ + KAPH + DAGESH, "a:kk"); 
     723         
     724        // TODO why is Kaph Dagesh not doubled to kk? 
    679725        addTest(ALEPH + KAPH + DAGESH, HOOK_LEFT + "k"); 
     726        // TODO and therefore k-k at the start? 
    680727        addTest(KAPH + DAGESH, "k"); 
     728         
    681729        addTest(ALEPH + KAPH, HOOK_LEFT + "x"); 
    682730        addTest(ALEPH + FINAL_KAPH, HOOK_LEFT + "x"); 
    683         addTest(LAMED + DAGESH, "ll"); 
     731        addTest(LAMED + DAGESH, "l-l"); // initial double consonants get a dash 
     732        addTest(ALEPH + LAMED + DAGESH, HOOK_LEFT + "ll"); 
    684733        addTest(LAMED, "l"); 
    685         addTest(MEM + DAGESH, "mm"); 
     734        addTest(MEM + DAGESH, "m-m"); // initial double consonants get a dash 
     735        addTest(ALEPH + MEM + DAGESH, HOOK_LEFT + "mm"); 
    686736        addTest(MEM, "m"); 
    687737        addTest(FINAL_MEM, "m"); 
    688         addTest(NUN + DAGESH, "nn"); 
     738        addTest(NUN + DAGESH, "n-n"); // initial double consonants get a dash 
     739        addTest(ALEPH + NUN + DAGESH, HOOK_LEFT + "nn");  
    689740        addTest(NUN, "n"); 
    690741        addTest(FINAL_NUN, "n"); 
     
    699750        addTest(ALEPH + PE, HOOK_LEFT + "f"); 
    700751        addTest(ALEPH + FINAL_PE, HOOK_LEFT + "f"); 
    701         addTest(QOPH + DAGESH, "qq"); 
     752        addTest(QOPH + DAGESH, "q-q"); // initial double consonants get a dash 
     753        addTest(ALEPH + QOPH + DAGESH, HOOK_LEFT + "qq"); 
    702754        addTest(QOPH, "q"); 
    703755        addTest(RESH, "r"); 
    704         addTest(SAMEK + DAGESH, "ss"); 
     756        addTest(SAMEK + DAGESH, "s-s"); // initial double consonants get a dash 
     757        addTest(ALEPH + SAMEK + DAGESH, HOOK_LEFT + "ss"); 
    705758        addTest(SAMEK, "s"); 
    706759        addTest(PATAH + SOF_PASUQ + TAV + DAGESH, "a:tt"); 
     
    708761        addTest(TAV, "t"); 
    709762        addTest(QIBBUTS, "u"); 
    710         addTest(TET + DAGESH, T_DOT + T_DOT); 
     763        addTest(TET + DAGESH, T_DOT + "-" + T_DOT); // initial double consonants get a dash  
     764        addTest(ALEPH + TET + DAGESH, HOOK_LEFT + T_DOT + T_DOT); 
    711765        addTest(TET, T_DOT); 
    712766        addTest(WAW + DAGESH, U_CARET); 
    713767        addTest(WAW, "w"); 
    714768        addTest(KHET, H_DOT); 
    715         addTest(TSADE + DAGESH, S_DOT + S_DOT); 
     769        addTest(TSADE + DAGESH, S_DOT + "-" + S_DOT); // initial double consonants get a dash  
     770        addTest(ALEPH + TSADE + DAGESH, HOOK_LEFT + S_DOT + S_DOT); 
    716771        addTest(TSADE, S_DOT); 
    717772        addTest(FINAL_TSADE, S_DOT); 
    718         addTest(ZAYIN + DAGESH, "zz"); 
     773        addTest(ZAYIN + DAGESH, "z-z"); // initial double consonants get a dash  
     774        addTest(ALEPH + ZAYIN + DAGESH, HOOK_LEFT + "zz"); 
    719775        addTest(ZAYIN, "z"); 
    720776         
     
    744800        morphs.add(new Morpheme("ֹת֞֔י", "FplCS", "N/GNS", true, true)); 
    745801        morphs.add(new Morpheme("ו", "3Msg", "N/POS", true, true)); 
    746         assertEquals("ṣṣalʕ", m_trans.transliterate(morphs, 0, ms_EmptyMap)); 
     802        assertEquals("á¹£-á¹£alʕ", m_trans.transliterate(morphs, 0, ms_EmptyMap)); 
    747803        assertEquals("ōtāʞ", m_trans.transliterate(morphs, 1, ms_EmptyMap)); 
    748804        assertEquals("w", m_trans.transliterate(morphs, 2, ms_EmptyMap)); 
     
    9701026        } 
    9711027    } 
     1028     
    9721029    public static void main(String[] args) 
    9731030    {