ICU-6.2.22.tar.gz

[apple/icu.git] / icuSources / data / translit / Latin_Jamo.txt

#--------------------------------------------------------------------
# Copyright (c) 1999-2004, International Business Machines
# Corporation and others. All Rights Reserved.
#--------------------------------------------------------------------

#- N.B. DO NOT put any filters, NFD, etc. here -- those are aliased in
#- the INDEX file.  This transliterator is, by itself, not
#- instantiated.  It is used as a part of Latin-Jamo, Latin-Hangul, or
#- inverses thereof.

# Transliteration from Latin characters to Korean script is done in
# two steps: Latin to Jamo, then Jamo to Hangul.  The Jamo-Hangul
# transliteration is done algorithmically following Unicode 3.0
# section 3.11.  This file implements the Latin to Jamo
# transliteration using rules.

# Jamo occupy the block 1100-11FF.  Within this block there are three
# groups of characters: initial consonants or choseong (I), medial
# vowels or jungseong (M), and trailing consonants or jongseong (F).
# Standard Korean syllables are of the form I+M+F*.

# Section 3.11 describes the use of 'filler' jamo to convert
# nonstandard syllables to standard form: the choseong filler 115F and
# the junseong filler 1160.  In this transliterator, we will not use
# 115F or 1160.

# We will, however, insert two 'null' jamo to make foreign words
# conform to Korean syllable structure.  These are the null initial
# consonant 110B (IEUNG) and the null vowel 1173 (EU).  In Latin text,
# we will use the separator in order to disambiguate strings,
# e.g. "kan-ggan" (initial GG) vs. "kanggan" (final NG + initial G).

# We will not use all of the characters in the jamo block.  We will
# only use the 19 initials, 21 medials, and 27 finals possessing a
# jamo short name as defined in section 4.4 of the Unicode book.

# Rules of thumb.  These guidelines provide the basic framework
# for the rules.  They are phrased in terms of Latin-Jamo transliteration.
# The Jamo-Latin rules derive from these, since the Jamo-Latin rules are
# just context-free transliteration of jamo to corresponding short names,
# with the addition of separators to maintain round-trip integrity
# in the context of the Latin-Jamo rules.

# A sequence of vowels:
# - Take the longest sequence you can. If there are too many, or you don't
#   have a starting consonant, introduce a 110B necessary.

# A sequence of consonants.
# - First join the double consonants: G + G -> GG
# - In the remaining list,
# -- If there is no preceding vowel, take the first consonant, and insert EU
#    after it. Continue with the rest of the consonants.
# -- If there is one consonant, attach to the following vowel
# -- If there are two consonants and a following vowel, attach one to the
#    preceeding vowel, and one to the following vowel.
# -- If there are more than two consonants, join the first two together if you
#    can: L + G => LG
# -- If you still end up with more than 2 consonants, insert EU after the
#    first one, and continue with the rest of the consonants.

#----------------------------------------------------------------------
# Variables

# Some latin consonants or consonant pairs only occur as initials, and
# some only as finals, but some occur as both.  This makes some jamo
# consonants ambiguous when transliterated into latin.
#   Initial only: IEUNG BB DD JJ R
#   Final only: BS GS L LB LG LH LM LP LS LT NG NH NJ
#   Initial and Final: B C D G GG H J K M N P S SS T

  $Gi = \u1100;
  $GGi = \u1101;
  $Ni = \u1102;
  $Di = \u1103;
  $DD = \u1104;
  $R = \u1105;
  $Mi = \u1106;
  $Bi = \u1107;
  $BB = \u1108;
  $Si = \u1109;
  $SSi = \u110A;
  $IEUNG = \u110B; # null initial, inserted during Latin-Jamo
  $Ji = \u110C;
  $JJ = \u110D;
  $Ci = \u110E;
  $Ki = \u110F;
  $Ti = \u1110;
  $Pi = \u1111;
  $Hi = \u1112;

  $A = \u1161;
  $AE = \u1162;
  $YA = \u1163;
  $YAE = \u1164;
  $EO = \u1165;
  $E = \u1166;
  $YEO = \u1167;
  $YE = \u1168;
  $O = \u1169;
  $WA = \u116A;
  $WAE = \u116B;
  $OE = \u116C;
  $YO = \u116D;
  $U = \u116E;
  $WEO = \u116F;
  $WE = \u1170;
  $WI = \u1171;
  $YU = \u1172;
  $EU = \u1173; # null medial, inserted during Latin-Jamo
  $YI = \u1174;
  $I = \u1175;

  $Gf = \u11A8;
  $GGf = \u11A9;
  $GS = \u11AA;
  $Nf = \u11AB;
  $NJ = \u11AC;
  $NH = \u11AD;
  $Df = \u11AE;
  $L = \u11AF;
  $LG = \u11B0;
  $LM = \u11B1;
  $LB = \u11B2;
  $LS = \u11B3;
  $LT = \u11B4;
  $LP = \u11B5;
  $LH = \u11B6;
  $Mf = \u11B7;
  $Bf = \u11B8;
  $BS = \u11B9;
  $Sf = \u11BA;
  $SSf = \u11BB;
  $NG = \u11BC;
  $Jf = \u11BD;
  $Cf = \u11BE;
  $Kf = \u11BF;
  $Tf = \u11C0;
  $Pf = \u11C1;
  $Hf = \u11C2;
  
  $jamoInitial = [\u1100-\u1112];

  $jamoMedial = [\u1161-\u1175];

  $latinInitial = [bcdghjkmnprst];

  # Any character in the latin transliteration of a medial
  $latinMedial = [aeiouwy];

  # The last character of the latin transliteration of a medial
  $latinMedialEnd = [aeiou];

  # Disambiguation separator
  $sep = \';

#----------------------------------------------------------------------
# Jamo-Latin

# Jamo to latin is relatively simple, since it is the latin that is
# ambiguous.  Most rules are straightforward, and we encode them below
# as simple add-on back rule, e.g.:

#   $jamoMedial {bs} > $BS;

# becomes

#   $jamoMedial {bs} <> $BS;

# Furthermore, we don't care about the ordering for Jamo-Latin because
# we are going from single characters, so we can very easily piggyback
# on the Latin-Jamo.

# The main issue with Jamo-Latin is when to insert separators.
# Separators are inserted to obtain correct round trip behavior.  For
# example, the sequence Ki A Gf Gi E, if transliterated to "kagge",
# would then round trip to Ki A GGi E.  To prevent this, we insert a
# separator: "kag-ge".  IMPORTANT: The need for separators depends
# very specifically on the behavior of the Latin-Jamo rules.  A change
# in the Latin-Jamo behavior can completely change the way the
# separator insertion must be done.

# First try to preserve actual separators in the jamo text by doubling
# them.  This fixes problems like:
# (Di)(A)(Ji)(U)(NG)-(IEUNG)(YEO)(Nf)(Gi)(YEO)(L) => dajung-yeongyeol
# => (Di)(A)(Ji)(U)(NG)(IEUNG)(YEO)(Nf)(Gi)(YEO)(L).  This is optional
# -- if we don't care about losing separators in the jamo, we can delete
# this rule.

  $sep $sep <> $sep;

# Triple consonants.  For three consonants "axxx" we insert a
# separator between the first and second "x" if XXf, Xf, and Xi all
# exist, and we have A Xf XXi.  This prevents the reverse
# transliteration to A XXf Xi.

  $sep < $latinMedialEnd g {} $GGi;
  $sep < $latinMedialEnd s {} $SSi;

# For vowels the rule is similar.  If there is a vowel "ae" such that
# "a" by itself and "e" by itself are vowels, then we want to map A E
# to "a-e" so as not to round trip to AE.  However, in the text Ki EO
# IEUNG E we don't need to map to "keo-e".  "keoe" suffices.  For
# vowels of the form "aei", both "ae" + "i" and "a" + "ei" must be
# tested.  NOTE: These rules used to have a left context of
# $latinInitial instead of [^$latinMedial].  The problem with this is
# sequences where an initial IEUNG is transliterated away:
#   (IEUNG)(A)(IEUNG)(EO) => aeo => (IEUNG)(AE)(IEUNG)(O)

  $sep < [^$latinMedial] [y w] e {} [$O $OE];
  $sep < [^$latinMedial] e {} [$O $OE $U];
  $sep < [^$latinMedial] [o a] {} [$E $EO $EU];
  $sep < [^$latinMedial] [w y] a {} [$E $EO $EU];

# Similar to the above, but with an intervening $IEUNG.

  $sep < [^$latinMedial] [y w] e {} $IEUNG [$O $OE];
  $sep < [^$latinMedial] e {} $IEUNG [$O $OE $U];
  $sep < [^$latinMedial] [o a] {} $IEUNG [$E $EO $EU];
  $sep < [^$latinMedial] [w y] a {} $IEUNG [$E $EO $EU];

# Single finals followed by IEUNG.  The jamo sequence A Xf IEUNG E,
# where Xi also exists, must be transliterated as "ax-e" to prevent
# the round trip conversion to A Xi E.

  $sep < $latinMedialEnd b {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd c {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd d {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd g {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd h {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd j {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd k {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd m {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd n {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd p {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd s {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd t {} $IEUNG $jamoMedial;

# Double finals followed by IEUNG.  Similar to the single finals
# followed by IEUNG.  Any latin consonant pair X Y, between medials,
# that we would split by Latin-Jamo, we must handle when it occurs as
# part of A XYf IEUNG E, to prevent round trip conversion to A Xf Yi
# E.

  $sep < $latinMedialEnd b s {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd g g {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd g s {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd l b {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd l g {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd l h {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd l m {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd l p {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd l s {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd l t {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd n g {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd n h {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd n j {} $IEUNG $jamoMedial;
  $sep < $latinMedialEnd s s {} $IEUNG $jamoMedial;

# Split doubles.  Text of the form A Xi Xf E, where XXi also occurs,
# we transliterate as "ax-xe" to prevent round trip transliteration as
# A XXi E.

  $sep < $latinMedialEnd b {} $Bi $jamoMedial;
  $sep < $latinMedialEnd d {} $Di $jamoMedial;
  $sep < $latinMedialEnd j {} $Ji $jamoMedial;
  $sep < $latinMedialEnd g {} $Gi $jamoMedial;
  $sep < $latinMedialEnd s {} $Si $jamoMedial;

# XYY.  This corresponds to the XYY rule in Latin-Jamo.  By default
# Latin-Jamo maps "xyy" to Xf YYi, to keep YY together.  As a result,
# "xyy" forms that correspond to XYf Yi must be transliterated as
# "xy-y".

  $sep < $latinMedialEnd b s {} [$Si $SSi];
  $sep < $latinMedialEnd g s {} [$Si $SSi];
  $sep < $latinMedialEnd l b {} [$Bi $BB];
  $sep < $latinMedialEnd l g {} [$Gi $GGi];
  $sep < $latinMedialEnd l s {} [$Si $SSi];
  $sep < $latinMedialEnd n g {} [$Gi $GGi];
  $sep < $latinMedialEnd n j {} [$Ji $JJ];

# Deletion of IEUNG is handled below.

#----------------------------------------------------------------------
# Latin-Jamo

# [Basic, context-free Jamo-Latin rules are embedded here too.  See
# above.]

# Split digraphs: Text of the form 'axye', where 'xy' is a final
# digraph, 'x' is a final (by itself), 'y' is an initial, and 'a' and
# 'e' are medials, we want to transliterate this as A Xf Yi E rather
# than A XYf IEUNG E.  We do NOT include text of the form "axxe",
# since that is handled differently below.  These rules are generated
# programmatically from the jamo data.

  $jamoMedial {b s} $latinMedial > $Bf $Si;
  $jamoMedial {g s} $latinMedial > $Gf $Si;
  $jamoMedial {l b} $latinMedial > $L $Bi;
  $jamoMedial {l g} $latinMedial > $L $Gi;
  $jamoMedial {l h} $latinMedial > $L $Hi;
  $jamoMedial {l m} $latinMedial > $L $Mi;
  $jamoMedial {l p} $latinMedial > $L $Pi;
  $jamoMedial {l s} $latinMedial > $L $Si;
  $jamoMedial {l t} $latinMedial > $L $Ti;
  $jamoMedial {n g} $latinMedial > $Nf $Gi;
  $jamoMedial {n h} $latinMedial > $Nf $Hi;
  $jamoMedial {n j} $latinMedial > $Nf $Ji;

# Single consonants are initials: Text of the form 'axe', where 'x'
# can be an initial or a final, and 'a' and 'e' are medials, we want
# to transliterate as A Xi E rather than A Xf IEUNG E.

  $jamoMedial {b} $latinMedial > $Bi;
  $jamoMedial {c} $latinMedial > $Ci;
  $jamoMedial {d} $latinMedial > $Di;
  $jamoMedial {g} $latinMedial > $Gi;
  $jamoMedial {h} $latinMedial > $Hi;
  $jamoMedial {j} $latinMedial > $Ji;
  $jamoMedial {k} $latinMedial > $Ki;
  $jamoMedial {m} $latinMedial > $Mi;
  $jamoMedial {n} $latinMedial > $Ni;
  $jamoMedial {p} $latinMedial > $Pi;
  $jamoMedial {s} $latinMedial > $Si;
  $jamoMedial {t} $latinMedial > $Ti;

# Doubled initials.  The sequence "axxe", where XX exists as an initial
# (XXi), and also Xi and Xf exist (true of all digraphs XX), we want
# to transliterate as A XXi E, rather than split to A Xf Xi E.

  $jamoMedial {b b} $latinMedial > $BB;
  $jamoMedial {d d} $latinMedial > $DD;
  $jamoMedial {j j} $latinMedial > $JJ;
  $jamoMedial {g g} $latinMedial > $GGi;
  $jamoMedial {s s} $latinMedial > $SSi;

# XYY.  Because doubled consonants bind more strongly than XY
# consonants, we must handle the sequence "axyy" specially.  Here XYf
# and YYi must exist.  In these cases, we map to Xf YYi rather than
# XYf.

  $jamoMedial {b} s s > $Bf;
  $jamoMedial {g} s s > $Gf;
  $jamoMedial {l} b b > $L;
  $jamoMedial {l} g g > $L;
  $jamoMedial {l} s s > $L;
  $jamoMedial {n} g g > $Nf;
  $jamoMedial {n} j j > $Nf;

# Finals: Attach consonant with preceding medial to preceding medial.
# Do this BEFORE mapping consonants to initials.  Longer keys must
# precede shorter keys that they start with, e.g., the rule for 'bs'
# must precede 'b'.

# [BASIC Jamo-Latin FINALS handled here.  Order irrelevant within this
# block for Jamo-Latin.]

  $jamoMedial {bs} <> $BS;
  $jamoMedial {b} <> $Bf;
  $jamoMedial {c} <> $Cf;
  $jamoMedial {d} <> $Df;
  $jamoMedial {gg} <> $GGf;
  $jamoMedial {gs} <> $GS;
  $jamoMedial {g} <> $Gf;
  $jamoMedial {h} <> $Hf;
  $jamoMedial {j} <> $Jf;
  $jamoMedial {k} <> $Kf;
  $jamoMedial {lb} <> $LB;  $jamoMedial {lg} <> $LG;
  $jamoMedial {lh} <> $LH;
  $jamoMedial {lm} <> $LM;
  $jamoMedial {lp} <> $LP;
  $jamoMedial {ls} <> $LS;
  $jamoMedial {lt} <> $LT;
  $jamoMedial {l} <> $L;
  $jamoMedial {m} <> $Mf;
  $jamoMedial {ng} <> $NG;
  $jamoMedial {nh} <> $NH;
  $jamoMedial {nj} <> $NJ;
  $jamoMedial {n} <> $Nf;
  $jamoMedial {p} <> $Pf;
  $jamoMedial {ss} <> $SSf;
  $jamoMedial {s} <> $Sf;
  $jamoMedial {t} <> $Tf;

# Initials: Attach single consonant to following medial.  Do this
# AFTER mapping finals.  Longer keys must precede shorter keys that
# they start with, e.g., the rule for 'gg' must precede 'g'.

# [BASIC Jamo-Latin INITIALS handled here.  Order irrelevant within
# this block for Jamo-Latin.]

  {gg} $latinMedial <> $GGi;
  {g} $latinMedial <> $Gi;
  {n} $latinMedial <> $Ni;
  {dd} $latinMedial <> $DD;
  {d} $latinMedial <> $Di;
  {r} $latinMedial <> $R;
  {m} $latinMedial <> $Mi;
  {bb} $latinMedial <> $BB;
  {b} $latinMedial <> $Bi;
  {ss} $latinMedial <> $SSi;
  {s} $latinMedial <> $Si;
  {jj} $latinMedial <> $JJ;
  {j} $latinMedial <> $Ji;
  {c} $latinMedial <> $Ci;
  {k} $latinMedial <> $Ki;
  {t} $latinMedial <> $Ti;
  {p} $latinMedial <> $Pi;
  {h} $latinMedial <> $Hi;

# 'r' in final position.  Because of the equivalency of the 'l' and
# 'r' jamo (the glyphs are the same), we try to provide the same
# equivalency in Latin-Jamo.  The 'l' to 'r' conversion is handled
# below.  If we see an 'r' in an apparent final position, treat it
# like 'l'.  For example, "karka" => Ki A R EU Ki A without this rule.
# Instead, we want Ki A L Ki A.

  $jamoMedial {r} $latinInitial > | l;

# Initial + Final: If we match the next rule, we have initial then
# final consonant with no intervening medial.  We insert the null
# vowel BEFORE it to create a well-formed syllable.  (In the next rule
# we insert a null vowel AFTER an anomalous initial.)

  $jamoInitial {} [bcdghjklmnpst] > $EU;

# Initial + X: This block matches an initial consonant not followed by
# a medial.  We insert the null vowel after it.  We handle double
# initials explicitly here; for single initial consonants we insert EU
# (as Latin) after them and let standard rules do the rest.

# BREAKS ROUND TRIP INTEGRITY

  gg > $GGi $EU;
  dd > $DD $EU;
  bb > $BB $EU;
  ss > $SSi $EU;
  jj > $JJ $EU;

  ([bcdghjkmnprst]) > | $1 eu;

# X + Final: Finally we have to deal with a consonant that can only be
# interpreted as a final (not an initial) and which is preceded
# neither by an initial nor a medial.  It is the start of the
# syllable, but cannot be.  Most of these will already be handled by
# the above rules.  'bs' splits into Bi EU Sf.  Similar for 'gs' 'ng'
# 'nh' 'nj'.  The only problem is 'l' and digraphs starting with 'l'.
# For this isolated case, we could add a null initial and medial,
# which would give "la" => IEUNG EU L IEUNG A, for example.  A more
# economical solution is to transliterate isolated "l" (that is,
# initial "l") to "r".  (Other similar conversions of consonants that
# occur neither as initials nor as finals are handled below.)

  l > | r;

# Medials.  If a medial is preceded by an initial, then we proceed
# normally.  As usual, longer keys must precede shorter ones.

# [BASIC Jamo-Latin MEDIALS handled here.  Order irrelevant within
# this block for Jamo-Latin.]

  $jamoInitial {ae} <> $AE;
  $jamoInitial {a} <> $A;
  $jamoInitial {eo} <> $EO;
  $jamoInitial {eu} <> $EU;
  $jamoInitial {e} <> $E;
  $jamoInitial {i} <> $I;
  $jamoInitial {oe} <> $OE;
  $jamoInitial {o} <> $O;
  $jamoInitial {u} <> $U;
  $jamoInitial {wae} <> $WAE;
  $jamoInitial {wa} <> $WA;
  $jamoInitial {weo} <> $WEO;
  $jamoInitial {we} <> $WE;
  $jamoInitial {wi} <> $WI;
  $jamoInitial {yae} <> $YAE;
  $jamoInitial {ya} <> $YA;
  $jamoInitial {yeo} <> $YEO;
  $jamoInitial {ye} <> $YE;
  $jamoInitial {yi} <> $YI;
  $jamoInitial {yo} <> $YO;
  $jamoInitial {yu} <> $YU;

# We may see an anomalous isolated 'w' or 'y'.  In that case, we
# interpret it as 'wi' and 'yu', respectively.

# BREAKS ROUND TRIP INTEGRITY

  $jamoInitial {w} > | wi;
  $jamoInitial {y} > | yu;

# Otherwise, insert a null consonant IEUNG before the medial (which is
# still an untransliterated latin vowel).

  ($latinMedial) > $IEUNG | $1;

# Convert non-jamo latin consonants to equivalents.  These occur as
# neither initials nor finals in jamo.  'l' occurs as a final, but not
# an initial; it is handled above.  The following letters (left hand
# side) will never be output by Jamo-Latin.

  f > | p;
  q > | k;
  v > | b;
  x > | ks;
  z > | s;

# Delete separators (Latin-Jamo).

  $sep > ;

# Delete null consonants (Jamo-Latin).  Do NOT delete null EU vowels,
# since these may also occur in text.

  < $IEUNG;

#- N.B. DO NOT put any filters, NFD, etc. here -- those are aliased in
#- the INDEX file.  This transliterator is, by itself, not
#- instantiated.  It is used as a part of Latin-Jamo, Latin-Hangul, or
#- inverses thereof.

# eof