thdltools/Jskad
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Jskad/source/org/thdl/tib/text/TibetanSyllable.java

1116 lines
No EOL
34 KiB
Java
Raw Blame History

/*
* The contents of this file are subject to the THDL Open Community License
* Version 1.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License on the THDL web site
* (http://www.thdl.org/).
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
* the specific terms governing rights and limitations under the License.
*
* The Initial Developer of this software is the Tibetan and Himalayan Digital
* Library (THDL).
*
* Copyright 2001 Tashi Tsering All Rights Reserved
*
* Contributor(s): ______________________________________.
*/
/*
* //************************************************************************** // //
* This is the java version of the class of TibetanSyllable // represented by
* Wylie translateration system. Use the class, Tibetan // syllables can be
* compared. And also one can sort Tibetan syllables, words, // phrases and
* sentences by comparison of two syllables. The order of the // consonants and
* the order of the vowels are based on "tshig mdzod chen mo" // (The Big
* Dictionary). // // // Author: Tashi Tsering // Date: 11/27/2002 // Written
* at: University of Virginia //
* //***********************************************************************************
* //The interface of the class of TibetanSyllable: // //class name:
* TibetanSyllable // //constructor: TibetanSyllable ( String S ) // String S is
* the representation of a Tibetan syllable by string. // //method: // int
* CompareWith( TibetanSyllable thatSyllable ) // // return: 0 if this syllable
* is the same with thatSyllable; // 1 if this syllable is bigger than
* thatSyllable, // i.e. this syllable goes after thatSyllable in the order of a
* dictionary; // -1 if this syllable is less than thatSyllable, // i.e. this
* syllable goes before thatSyllable in the order of a dictionary; // Those
* invalid syllables will be treated as the biggest syllable, that they are
* always // bigger than valid syllables.;
* //************************************************************************************ //
*/
package org.thdl.tib.text;
public class TibetanSyllable implements Comparable
{
/** The character String of the syllable. */
private String theSyllable;
/** True for Tibetan syllable, false for Sanskrit syllable. */
private boolean TibetanSyllableFlag;
/** Number of Tibetan characters represented by Wylie system
* in the syllable. */
private int nComponents;
/** The number of vowels in the syllable. */
private int nVowels;
/** Components of a syllable consists of Tibetan Wylie "characters". */
private String[][] Components;
// Components[0][0]-----Base letter
// Components[0][1]-----Superscript
// Components[0][2]-----Prefix
// Components[0][3]-----Subscript
// Components[0][4]-----vowel
// Components[0][5]-----Suffix
// Components[0][6]-----Second suffix
//You can add your own method to return different component of a syllable.
/** The constructor */
public TibetanSyllable(String s) {
//Filter the spaces that are at the beginning or end of the syllable.
/*
* while (s.length()>0) if(s.charAt(0) == ' ' && s.length()>1) s =
* s.substring(1,s.length()); else if(s.charAt(s.length()-1) == ' ' &&
* s.length()>1) s = s.substring(0, s.length()-1); else break;
*/
theSyllable = s.trim();
ItsComponents();
}
public int compareTo(Object o)
{
TibetanSyllable s = (TibetanSyllable) o;
int getnV = s.GetnVowels(), n = (nVowels > getnV) ? nVowels : getnV, valueOfThis, valueOfThat;
String[][] temp;
temp = s.GetComponents();
for (int i = 0; i < n; i++) {
for (int j = 0; j < 10; j++) {
valueOfThis = ValueOfTibetanCharacter(Components[i][j]);
valueOfThat = ValueOfTibetanCharacter(temp[i][j]);
if (valueOfThis > valueOfThat)
return 1; // This syllable is bigger than that syllable s.
else if (valueOfThis < valueOfThat)
return -1; // This syllable is smaller than that syllable s.
}
}
return 0; // They are the same syllable.
}
/** Return the base letter of a syllable. */
public String BaseLetter() {
return Components[0][0];
}
public boolean IsTibetanSyllable() {
return TibetanSyllableFlag;
}
public String GetTheSyllable() {
return theSyllable;
}
public String toString()
{
return theSyllable;
}
public void SetTheSyllable(String s) {
theSyllable = s;
}
private String[][] GetComponents() {
return Components;
}
private int GetnComponents() {
return nComponents;
}
private int ItsLength() {
return nComponents;
}
private int GetnVowels() {
return nVowels;
}
/** To examine a component to see if it is a vowel. Return true if the
* component is vowel.*/
public static boolean IsTibetanVowel(String thecomponent) {
if ((thecomponent.equals("a")) || (thecomponent.equals("i"))
|| (thecomponent.equals("u")) || (thecomponent.equals("e"))
|| (thecomponent.equals("o")))
return true;
else
return false;
}
/** To examine a component, see if it is a prefix. Return true if the
* component is prefix. */
public static boolean IsPrefix(String thecomponent) {
if ((thecomponent.equals("g")) || (thecomponent.equals("d"))
|| (thecomponent.equals("b")) || (thecomponent.equals("m"))
|| (thecomponent.equals("'")))
return true;
else
return false;
}
/** To examine a component, see if it is a base letter.
* Return true if it is.
*/
public static boolean IsBaseLetter(String thecomponent) {
if ((thecomponent.equals("k")) || (thecomponent.equals("kh"))
|| (thecomponent.equals("g")) || (thecomponent.equals("ng"))
|| (thecomponent.equals("c")) || (thecomponent.equals("ch"))
|| (thecomponent.equals("j")) || (thecomponent.equals("ny"))
|| (thecomponent.equals("t")) || (thecomponent.equals("th"))
|| (thecomponent.equals("d")) || (thecomponent.equals("n"))
|| (thecomponent.equals("p")) || (thecomponent.equals("ph"))
|| (thecomponent.equals("b")) || (thecomponent.equals("m"))
|| (thecomponent.equals("ts")) || (thecomponent.equals("tsh"))
|| (thecomponent.equals("dz")) || (thecomponent.equals("w"))
|| (thecomponent.equals("zh")) || (thecomponent.equals("z"))
|| (thecomponent.equals("'")) || (thecomponent.equals("y"))
|| (thecomponent.equals(".y")) || //Special for making "g.ya"
// different from gya.
(thecomponent.equals("r")) || (thecomponent.equals("l"))
|| (thecomponent.equals("sh")) || (thecomponent.equals("s"))
|| (thecomponent.equals("h")) || (thecomponent.equals("a")))
return true;
else
return false;
}
/** To examine a component, see if it is a supperscript.
* Return true if it is, otherwise false.*/
public static boolean IsSuperscript(String thecomponent) {
if ((thecomponent.equals("r")) || (thecomponent.equals("l"))
|| (thecomponent.equals("s")))
return true;
else
return false;
}
/** To examine a component, see if it is a subscript.
* Return true if it is, otherwise false. */
public static boolean IsSubscript(String thecomponent) {
if ((thecomponent.equals("w")) || (thecomponent.equals("y"))
|| (thecomponent.equals("r")) || (thecomponent.equals("l")))
return true;
else
return false;
}
/** To examine a component, see if it is a suffix.
* Return true if it is, otherwise false. */
public static boolean IsSuffix(String thecomponent) {
if ((thecomponent.equals("g")) || (thecomponent.equals("ng"))
|| (thecomponent.equals("d")) || (thecomponent.equals("n"))
|| (thecomponent.equals("b")) || (thecomponent.equals("m"))
|| (thecomponent.equals("'")) || (thecomponent.equals("r"))
|| (thecomponent.equals("l")) || (thecomponent.equals("s")))
return true;
else
return false;
}
/** To examine a component, see if it is a the second suffix.
* Return true if it is, otherwise false. */
public static boolean IsSecondSuffix(String thecomponent) {
if (thecomponent.equals("s"))
return true;
else
return false;
}
/** To examine a component, see if it is a Sanskrit consonant.
* Return true if it is, otherwise false. */
public static boolean IsSanskritConsonant(String thecomponent) {
if ((thecomponent.equals("T")) || (thecomponent.equals("Th"))
|| (thecomponent.equals("D")) || (thecomponent.equals("N"))
|| (thecomponent.equals("Sh")) || (thecomponent.equals("M"))
|| (thecomponent.equals("`")) || (thecomponent.equals("f"))
|| (thecomponent.equals("v")))
return true;
else
return false;
}
/** To examine a component, see if it is a Sanskrit vowel.
* Return true if it is, otherwise false.
*/
public static boolean IsSanskritVowel(String thecomponent) {
if ((thecomponent.equals("A")) || (thecomponent.equals("I"))
|| (thecomponent.equals("U")) || (thecomponent.equals("-i"))
|| (thecomponent.equals("-I")) || (thecomponent.equals("ai"))
|| (thecomponent.equals("au")))
return true;
else
return false;
}
/** To examine a component, see if it is a Sanskrit symbole.
* Return true if it is, otherwise false.
*/
public static boolean IsSanskritSpecialSymbol(String thecomponent) {
if ((thecomponent.equals("+")))
return true;
else
return false;
}
/** To examine a component, see if it is a Tibetan symbol.
* Return true if it is, otherwise false.
*/
public static boolean IsThisTibetanSymbol(String thecomponent) {
if (IsTibetanVowel(thecomponent) || IsBaseLetter(thecomponent))
return true;
else
return false;
}
/** To examine a component, see if it is a Sanskrit symbol.
* Return true if it is, otherwise false.
*/
public static boolean IsThisSanskritSymbol(String thecomponent) {
if (IsSanskritVowel(thecomponent) || IsSanskritConsonant(thecomponent)
|| IsSanskritSpecialSymbol(thecomponent))
return true;
else
return false;
}
/** To examine a component, see if it is a Tibetan symbol.
* Return true if it is, otherwise false.
*/
public static boolean IsThisTibetanOrSanskritSymbol(String thecomponent) {
if (IsThisTibetanSymbol(thecomponent)
|| IsThisSanskritSymbol(thecomponent))
return true;
else
return false;
}
/** To examine a component, see if it is a Tibetan or Sanskrit symbol.
* Return true if it is, otherwise false.
* @return
*/
public static boolean IsThisTibetanOrSanskritVowel(String thecomponent) {
if (IsSanskritVowel(thecomponent) || IsTibetanVowel(thecomponent))
return true;
else
return false;
}
/** To examine a pair of components, see if one of them is a prefix
* and the other one is a base letter that can follow the prefix.
* Return true if it is, otherwise false.
*/
public static boolean PrefixBaseletterMatch(String prefix, String baseletter) {
char c;
if (prefix.length() != 1)
return false; //No prefix.
else
c = prefix.charAt(0);
switch (c) {
case 'g':
if ((baseletter.equals("c")) || (baseletter.equals("ny"))
|| (baseletter.equals("t")) || (baseletter.equals("d"))
|| (baseletter.equals("n")) || (baseletter.equals("ts"))
|| (baseletter.equals("zh")) || (baseletter.equals("z"))
|| (baseletter.equals("sh")) || (baseletter.equals("s"))
|| (baseletter.equals(".y")))
return true;
else
return false;
case 'd':
if ((baseletter.equals("k")) || (baseletter.equals("p"))
|| (baseletter.equals("g")) || (baseletter.equals("b"))
|| (baseletter.equals("ng")) || (baseletter.equals("m")))
return true;
else
return false;
case 'b':
if ((baseletter.equals("c")) || (baseletter.equals("g"))
|| (baseletter.equals("t")) || (baseletter.equals("d"))
|| (baseletter.equals("ts")) || (baseletter.equals("zh"))
|| (baseletter.equals("z")) || (baseletter.equals("sh"))
|| (baseletter.equals("s")) || (baseletter.equals("k")))
return true;
else
return false;
case 'm':
if ((baseletter.equals("kh")) || (baseletter.equals("ch"))
|| (baseletter.equals("th")) || (baseletter.equals("tsh"))
|| (baseletter.equals("g")) || (baseletter.equals("j"))
|| (baseletter.equals("d")) || (baseletter.equals("dz"))
|| (baseletter.equals("ng")) || (baseletter.equals("ny"))
|| (baseletter.equals("n")))
return true;
else
return false;
case '\'':
if ((baseletter.equals("kh")) || (baseletter.equals("ch"))
|| (baseletter.equals("th")) || (baseletter.equals("ph"))
|| (baseletter.equals("tsh")) || (baseletter.equals("g"))
|| (baseletter.equals("j")) || (baseletter.equals("d"))
|| (baseletter.equals("b")) || (baseletter.equals("dz")))
return true;
else
return false;
}
return false;
}
/** To examine a pair of components, see if one of them is a subscript
* and the other one is a base letter that can be followed by the subscript.
* Return true if it is, otherwise false.
*/
public static boolean BaseletterSubscriptMatch(String baseletter, String subscript) {
char c;
if (subscript.length() != 1)
return false; //No subscript.
else
c = subscript.charAt(0);
switch (c) {
case 'y':
if ((baseletter.equals("k")) || (baseletter.equals("kh"))
|| (baseletter.equals("g")) || (baseletter.equals("p"))
|| (baseletter.equals("ph")) || (baseletter.equals("b"))
|| (baseletter.equals("m")))
return true;
else
return false;
case 'r':
if ((baseletter.equals("k")) || (baseletter.equals("t"))
|| (baseletter.equals("p")) || (baseletter.equals("kh"))
|| (baseletter.equals("ph")) || (baseletter.equals("g"))
|| (baseletter.equals("d")) || (baseletter.equals("b"))
|| (baseletter.equals("h")) || (baseletter.equals("m"))
|| (baseletter.equals("s")))
return true;
else
return false;
case 'l':
if ((baseletter.equals("k")) || (baseletter.equals("g"))
|| (baseletter.equals("b")) || (baseletter.equals("r"))
|| (baseletter.equals("s")) || (baseletter.equals("z")))
return true;
else
return false;
case 'w':
if ((baseletter.equals("k")) || (baseletter.equals("kh"))
|| (baseletter.equals("g")) || (baseletter.equals("ny"))
|| (baseletter.equals("d")) || (baseletter.equals("ch"))
|| (baseletter.equals("zh")) || (baseletter.equals("z"))
|| (baseletter.equals("r")) || (baseletter.equals("l"))
|| (baseletter.equals("sh")) || (baseletter.equals("s"))
|| (baseletter.equals("h")))
return true;
else
return false;
}
return false;
}
/** To examine a pair of components, see if one of them is a superscript
* and the other one is a base letter that can follow the superscript.
* Return true if it is, otherwise false.
*/
public static boolean SuperscriptBaseletterMatch(String superscript, String baseletter) {
char c;
if (superscript.length() != 1)
return false; //No superscript.
else
c = superscript.charAt(0);
switch (c) {
case 'r':
if ((baseletter.equals("k")) || (baseletter.equals("t"))
|| (baseletter.equals("ts")) || (baseletter.equals("g"))
|| (baseletter.equals("j")) || (baseletter.equals("d"))
|| (baseletter.equals("b")) || (baseletter.equals("dz"))
|| (baseletter.equals("ng")) || (baseletter.equals("ny"))
|| (baseletter.equals("n")) || (baseletter.equals("m")))
return true;
else
return false;
case 'l':
if ((baseletter.equals("k")) || (baseletter.equals("c"))
|| (baseletter.equals("t")) || (baseletter.equals("p"))
|| (baseletter.equals("g")) || (baseletter.equals("j"))
|| (baseletter.equals("d")) || (baseletter.equals("b"))
|| (baseletter.equals("ng")) || (baseletter.equals("h")))
return true;
else
return false;
case 's':
if ((baseletter.equals("k")) || (baseletter.equals("t"))
|| (baseletter.equals("p")) || (baseletter.equals("ts"))
|| (baseletter.equals("g")) || (baseletter.equals("d"))
|| (baseletter.equals("b")) || (baseletter.equals("ng"))
|| (baseletter.equals("ny")) || (baseletter.equals("n"))
|| (baseletter.equals("m")))
return true;
else
return false;
}
return false;
}
/** Assign values for Tibetan Wylie characters for comparison.
*/
private int ValueOfTibetanCharacter(String theCharacter) {
if (theCharacter == null)
return 0;
if (theCharacter.equals("$"))
return 0; // For non-presence.
if (theCharacter.equals("k"))
return 1;
if (theCharacter.equals("kh"))
return 2;
if (theCharacter.equals("g"))
return 3;
if (theCharacter.equals("ng"))
return 4;
if (theCharacter.equals("c"))
return 5;
if (theCharacter.equals("ch"))
return 6;
if (theCharacter.equals("j"))
return 7;
if (theCharacter.equals("ny"))
return 8;
if (theCharacter.equals("T"))
return 9;
if (theCharacter.equals("Th"))
return 10;
if (theCharacter.equals("D"))
return 11;
if (theCharacter.equals("N"))
return 12;
if (theCharacter.equals("t"))
return 13;
if (theCharacter.equals("th"))
return 14;
if (theCharacter.equals("d"))
return 15;
if (theCharacter.equals("n"))
return 16;
if (theCharacter.equals("p"))
return 17;
if (theCharacter.equals("ph"))
return 18;
if (theCharacter.equals("b"))
return 19;
if (theCharacter.equals("m"))
return 20;
if (theCharacter.equals("ts"))
return 21;
if (theCharacter.equals("tsh"))
return 22;
if (theCharacter.equals("dz"))
return 23;
if (theCharacter.equals("w"))
return 24;
if (theCharacter.equals("zh"))
return 25;
if (theCharacter.equals("z"))
return 26;
if (theCharacter.equals("'"))
return 27;
if (theCharacter.equals("y"))
return 28;
if (theCharacter.equals(".y"))
return 28;
if (theCharacter.equals("r"))
return 29;
if (theCharacter.equals("l"))
return 30;
if (theCharacter.equals("sh"))
return 31;
if (theCharacter.equals("Sh"))
return 32;
if (theCharacter.equals("s"))
return 33;
if (theCharacter.equals("h"))
return 34;
if (theCharacter.equals("a"))
return 35;
// if(theCharacter.equals("a")) return 41;
if (theCharacter.equals("A"))
return 42;
if (theCharacter.equals("i"))
return 43;
if (theCharacter.equals("I"))
return 44;
if (theCharacter.equals("u"))
return 47;
if (theCharacter.equals("U"))
return 48;
if (theCharacter.equals("-i"))
return 45;
if (theCharacter.equals("-I"))
return 46;
if (theCharacter.equals("e"))
return 49;
if (theCharacter.equals("ai"))
return 50;
if (theCharacter.equals("o"))
return 51;
if (theCharacter.equals("au"))
return 52;
if (theCharacter.equals("invalid"))
return 100;
return 100;
}
/** This is the key function in the class, which
* extracts the components of a syllable from the
* Wylie string of the syllable and put them into
* the order in that we compare syllables each other.
*/
private void ItsComponents() {
String thisString;
String SyllableByComponents[] = new String[100]; // Syllable consist of
// and ordered by
// components
// represented
// by Tibetan Wylie characters. Assume there are no more than
Components = new String[10][20]; // 20 components in a syllable.
int s = 0;
nComponents = 0; // Number of Tibetan characters represented by Wylie
// system in the syllable.
int i = 0;
//Cut the String of the syllable into the consequence of Tibetan Wylie
// characters of the syllable.
while (i < theSyllable.length()) {
for (int j = 1; theSyllable.length() >= (i + j); j++) {
thisString = theSyllable.substring(i, i + j);
if (IsThisTibetanOrSanskritSymbol(thisString)) {
s = j;
continue;
}
if (theSyllable.length() > (i + j) && j < 3)
continue;
if (s != 0)
break;
else {
InValidSyllable();
return;
}
}
if (s == 0) {
InValidSyllable();
return;
}
if (!theSyllable.substring(i, i + s).equals("+"))
SyllableByComponents[nComponents++] = theSyllable.substring(i, i + s);
/*{
// InValidSyllable();
s = 0;
continue;
} //Take off the Sanskrit stacking symbol "+" from the String.*/
i = i + s;
s = 0;
}
int nVowel = 0; // Number of vowels in a syllable.
int nCBV[] = new int[6]; // Number of components before a vowel, assume
// there are 5 vowels in the syllable.
// Normallly, there is only one vowel, sometimes two vowels in a
// syllable.
int nCAV[] = new int[6]; // Number of components after vowel, assume
// there are 5 vowels in the syllable.
// Normallly, there is only one vowel, sometimes two vewls in a
// syllable.
boolean SanskritFlag = false; // Is the syllable Sanskrit?
TibetanSyllableFlag = true;
//Calculate nVowel, nCBV and nCAV.
for (i = 0; i < nComponents; i++) {
if (IsTibetanVowel(SyllableByComponents[i])) {
nVowel++;
} else if (IsSanskritVowel(SyllableByComponents[i])) {
SanskritFlag = true;
TibetanSyllableFlag = false;
nVowel++;
} else {
nCBV[nVowel + 1]++;
nCAV[nVowel]++;
if (IsThisSanskritSymbol(SyllableByComponents[i])) {
SanskritFlag = true;
TibetanSyllableFlag = false;
}
}
}
if (nVowel == 0) {
InValidSyllable();
return;
}
nVowels = nVowel;
for (i = 0; i < 10; i++)
for (int j = 0; j < 20; j++)
Components[i][j] = "$"; //Assume there are at most 20
// components before a vowel.
if (!SanskritFlag && nVowel < 3) { //For Tibetan syllable (Tibetan
// syllable has no more than 2
// vowels):
if (nVowel == 1) {
switch (nCBV[1]) {
case 0: //Special case for "a", the last letter in Tibetan
// letter list, and the sequences led by its "i",
//"o", "u" and "e".
Components[0][0] = "a";
Components[0][1] = "$";
Components[0][2] = "$";
Components[0][3] = "$";
Components[0][4] = SyllableByComponents[0];
Components[0][5] = SyllableByComponents[1];
Components[0][6] = SyllableByComponents[2];
break;
case 1:
Components[0][0] = SyllableByComponents[0];
Components[0][1] = "$";
Components[0][2] = "$";
Components[0][3] = "$";
Components[0][4] = SyllableByComponents[1];
Components[0][5] = SyllableByComponents[2];
Components[0][6] = SyllableByComponents[3];
break;
case 2:
if (PrefixBaseletterMatch(SyllableByComponents[0],
SyllableByComponents[1])) {
Components[0][0] = SyllableByComponents[1];
Components[0][1] = "$";
Components[0][2] = SyllableByComponents[0];
Components[0][3] = "$";
Components[0][4] = SyllableByComponents[2];
Components[0][5] = SyllableByComponents[3];
Components[0][6] = SyllableByComponents[4];
}
else if (BaseletterSubscriptMatch(SyllableByComponents[0],
SyllableByComponents[1])) {
Components[0][0] = SyllableByComponents[0];
Components[0][1] = "$";
Components[0][2] = "$";
Components[0][3] = SyllableByComponents[1];
Components[0][4] = SyllableByComponents[2];
Components[0][5] = SyllableByComponents[3];
Components[0][6] = SyllableByComponents[4];
}
else if (SuperscriptBaseletterMatch(
SyllableByComponents[0], SyllableByComponents[1])) {
Components[0][0] = SyllableByComponents[1];
Components[0][1] = SyllableByComponents[0];
Components[0][2] = "$";
Components[0][3] = "$";
Components[0][4] = SyllableByComponents[2];
Components[0][5] = SyllableByComponents[3];
Components[0][6] = SyllableByComponents[4];
}
else
InValidSyllable();
break;
case 3:
if (PrefixBaseletterMatch(SyllableByComponents[0],
SyllableByComponents[2])
&& SuperscriptBaseletterMatch(
SyllableByComponents[1],
SyllableByComponents[2])) {
Components[0][0] = SyllableByComponents[2];
Components[0][1] = SyllableByComponents[1];
Components[0][2] = SyllableByComponents[0];
Components[0][3] = "$";
Components[0][4] = SyllableByComponents[3];
Components[0][5] = SyllableByComponents[4];
Components[0][6] = SyllableByComponents[5];
}
else if (PrefixBaseletterMatch(SyllableByComponents[0],
SyllableByComponents[1])
&& BaseletterSubscriptMatch(
SyllableByComponents[1],
SyllableByComponents[2])) {
Components[0][0] = SyllableByComponents[1];
Components[0][1] = "$";
Components[0][2] = SyllableByComponents[0];
Components[0][3] = SyllableByComponents[2];
Components[0][4] = SyllableByComponents[3];
Components[0][5] = SyllableByComponents[4];
Components[0][6] = SyllableByComponents[5];
}
else if (SuperscriptBaseletterMatch(
SyllableByComponents[0], SyllableByComponents[1])
&& BaseletterSubscriptMatch(
SyllableByComponents[1],
SyllableByComponents[2])) {
Components[0][0] = SyllableByComponents[1];
Components[0][1] = SyllableByComponents[0];
Components[0][2] = "$";
Components[0][3] = SyllableByComponents[2];
Components[0][4] = SyllableByComponents[3];
Components[0][5] = SyllableByComponents[4];
Components[0][6] = SyllableByComponents[5];
}
//For special cases of "brja", "bsnya", "brla", "bsna", ...
else if ((SyllableByComponents[0]).equals("b")) {
if (SuperscriptBaseletterMatch(SyllableByComponents[1],
SyllableByComponents[2])) {
Components[0][0] = SyllableByComponents[2];
Components[0][1] = SyllableByComponents[1];
Components[0][2] = SyllableByComponents[0];
Components[0][3] = "$";
Components[0][4] = SyllableByComponents[3];
Components[0][5] = SyllableByComponents[4];
Components[0][6] = SyllableByComponents[5];
} else if (BaseletterSubscriptMatch(
SyllableByComponents[1],
SyllableByComponents[2])) {
Components[0][0] = SyllableByComponents[1];
Components[0][1] = "$";
Components[0][2] = SyllableByComponents[0];
Components[0][3] = SyllableByComponents[2];
Components[0][4] = SyllableByComponents[3];
Components[0][5] = SyllableByComponents[4];
Components[0][6] = SyllableByComponents[5];
} else
InValidSyllable();
}
else
InValidSyllable();
break;
case 4:
Components[0][0] = SyllableByComponents[2];
Components[0][1] = SyllableByComponents[1];
Components[0][2] = SyllableByComponents[0];
Components[0][3] = SyllableByComponents[3];
Components[0][4] = SyllableByComponents[4];
Components[0][5] = SyllableByComponents[5];
Components[0][6] = SyllableByComponents[6];
break;
}
}
else if (nVowel >= 2) { //For more than two vowel Tibetan syllable,
// like "nga'i", "tshu'u":
int StartPoint = nCBV[0];
for (int j = 0; j < nVowel; j++) {
for (i = 0; i < j + 1; i++)
StartPoint += nCBV[i];
StartPoint += j;
switch (nCBV[j + 1]) {
case 0: //Special case for "a", the last letter in Tibetan
// letter list, and the sequence led by its "i",
//"o", "u" and "e".
Components[j][0] = "a";
Components[j][1] = "$";
Components[j][2] = "$";
Components[j][3] = "$";
Components[j][4] = SyllableByComponents[StartPoint + 0];
Components[j][5] = SyllableByComponents[StartPoint + 1];
Components[j][6] = SyllableByComponents[StartPoint + 2];
break;
case 1:
Components[j][0] = SyllableByComponents[StartPoint + 0];
Components[j][1] = "$";
Components[j][2] = "$";
Components[j][3] = "$";
Components[j][4] = SyllableByComponents[StartPoint + 1];
Components[j][5] = "$";
Components[j][6] = "$";
break;
case 2:
if (PrefixBaseletterMatch(
SyllableByComponents[StartPoint + 0],
SyllableByComponents[StartPoint + 1])) {
Components[j][0] = SyllableByComponents[StartPoint + 1];
Components[j][1] = "$";
Components[j][2] = SyllableByComponents[StartPoint + 0];
Components[j][3] = "$";
Components[j][4] = SyllableByComponents[StartPoint + 2];
Components[j][5] = "$";
Components[j][6] = "$";
}
else if (BaseletterSubscriptMatch(
SyllableByComponents[StartPoint + 0],
SyllableByComponents[StartPoint + 1])) {
Components[j][0] = SyllableByComponents[StartPoint + 0];
Components[j][1] = "$";
Components[j][2] = "$";
Components[j][3] = SyllableByComponents[StartPoint + 1];
Components[j][4] = SyllableByComponents[StartPoint + 2];
Components[j][5] = "$";
Components[j][6] = "$";
}
else if (SuperscriptBaseletterMatch(
SyllableByComponents[StartPoint + 0],
SyllableByComponents[StartPoint + 1])) {
Components[j][0] = SyllableByComponents[StartPoint + 1];
Components[0][1] = SyllableByComponents[StartPoint + 0];
Components[j][2] = "$";
Components[j][3] = "$";
Components[j][4] = SyllableByComponents[StartPoint + 2];
Components[j][5] = "$";
Components[j][6] = "$";
}
else
InValidSyllable();
break;
case 3:
if (PrefixBaseletterMatch(
SyllableByComponents[StartPoint + 0],
SyllableByComponents[StartPoint + 2])
&& SuperscriptBaseletterMatch(
SyllableByComponents[StartPoint + 1],
SyllableByComponents[StartPoint + 2])) {
Components[j][0] = SyllableByComponents[StartPoint + 2];
Components[j][1] = SyllableByComponents[StartPoint + 1];
Components[j][2] = SyllableByComponents[StartPoint + 0];
Components[j][3] = "$";
Components[j][4] = SyllableByComponents[StartPoint + 3];
Components[j][5] = "$";
Components[j][6] = "$";
}
else if (PrefixBaseletterMatch(
SyllableByComponents[StartPoint + 0],
SyllableByComponents[StartPoint + 1])
&& BaseletterSubscriptMatch(
SyllableByComponents[StartPoint + 1],
SyllableByComponents[StartPoint + 2])) {
Components[j][0] = SyllableByComponents[StartPoint + 1];
Components[j][1] = "$";
Components[j][2] = SyllableByComponents[StartPoint + 0];
Components[j][3] = SyllableByComponents[StartPoint + 2];
Components[j][4] = SyllableByComponents[StartPoint + 3];
Components[j][5] = "$";
Components[j][6] = "$";
}
else if (SuperscriptBaseletterMatch(
SyllableByComponents[StartPoint + 0],
SyllableByComponents[StartPoint + 1])
&& BaseletterSubscriptMatch(
SyllableByComponents[StartPoint + 1],
SyllableByComponents[StartPoint + 2])) {
Components[j][0] = SyllableByComponents[StartPoint + 1];
Components[j][1] = SyllableByComponents[StartPoint + 0];
Components[j][2] = "$";
Components[j][3] = SyllableByComponents[StartPoint + 2];
Components[j][4] = SyllableByComponents[StartPoint + 3];
Components[j][5] = "$";
Components[j][6] = "$";
}
//For special cases of "brja", "bsnya", "brla", "bsna",
// ...
else if ((SyllableByComponents[StartPoint + 0])
.equals("b")) {
if (SuperscriptBaseletterMatch(
SyllableByComponents[StartPoint + 1],
SyllableByComponents[StartPoint + 2])) {
Components[j][0] = SyllableByComponents[StartPoint + 2];
Components[j][1] = SyllableByComponents[StartPoint + 1];
Components[j][2] = SyllableByComponents[StartPoint + 0];
Components[j][3] = "$";
Components[j][4] = SyllableByComponents[StartPoint + 3];
Components[j][5] = "$";
Components[j][6] = "$";
} else if (BaseletterSubscriptMatch(
SyllableByComponents[StartPoint + 1],
SyllableByComponents[StartPoint + 2])) {
Components[j][0] = SyllableByComponents[StartPoint + 1];
Components[j][1] = "$";
Components[j][2] = SyllableByComponents[StartPoint + 0];
Components[j][3] = SyllableByComponents[StartPoint + 2];
Components[j][4] = SyllableByComponents[StartPoint + 3];
Components[j][5] = "$";
Components[j][6] = "$";
} else
InValidSyllable();
} else
InValidSyllable();
break;
case 4:
Components[j][0] = SyllableByComponents[StartPoint + 2];
Components[j][1] = SyllableByComponents[StartPoint + 1];
Components[j][2] = SyllableByComponents[StartPoint + 0];
Components[j][3] = SyllableByComponents[StartPoint + 3];
Components[j][4] = SyllableByComponents[StartPoint + 4];
Components[j][5] = "$";
Components[j][6] = "$";
break;
}
}
} else {
InValidSyllable();
return;
}
}
else if (SanskritFlag) { //For Sanskrit syllable :
int StartPoint = nCBV[0];
for (int j = 0; j < nVowel; j++) {
for (i = 0; i < j + 1; i++)
StartPoint += nCBV[i];
StartPoint += j;
if (nCBV[j + 1] == 0) { //Special case for "a", the last letter
// in Tibetan letter list, and the
// sequences led by its "i",
//"o", "u" and "e".
Components[j][0] = SyllableByComponents[StartPoint
+ nCBV[j + 1]];
Components[j][1] = "$";
Components[j][2] = "$";
Components[j][3] = "$";
Components[j][4] = SyllableByComponents[StartPoint
+ nCBV[j + 1]];
for (i = 0; i < nCBV[j + 1]; i++)
Components[j][i + 1 + 4] = SyllableByComponents[StartPoint
+ i];
}
else {
Components[j][0] = SyllableByComponents[StartPoint + 0];
Components[j][1] = "$";
Components[j][2] = "$";
Components[j][3] = "$";
Components[j][4] = SyllableByComponents[StartPoint
+ nCBV[j + 1]];
for (i = 0; i < nCBV[j + 1]; i++)
Components[j][i + 1 + 4] = SyllableByComponents[StartPoint
+ i];
}
}
}
else {
InValidSyllable();
return;
}
}
/** For cleaning up the invalid syllables by throwing them at the end of the list.
*
* @throws RuntimeException
*/
private void InValidSyllable() throws RuntimeException {
nVowels = 1;
TibetanSyllableFlag = true;
// System.out.println("This is not a valid Tibetan syllable: "+theSyllable);
for (int i = 0; i < 10; i++)
for (int j = 0; j < 20; j++)
Components[i][j] = "invalid";
throw new RuntimeException("This is not a valid Tibetan syllable: "
+ theSyllable);
}
} //End of the class
Reference in a new issue View git blame Copy permalink