 // -*- Coding: utf-8; -*-
//--------------------------------------------------------------------
// Copyright (c) 1999-2004, International Business Machines
// Corporation and others.  All Rights Reserved.
//--------------------------------------------------------------------
// THIS IS A MACHINE-GENERATED FILE
// Tool: dumpICUrules.bat
// Source: ../../../impl/data/Transliterator_Latin_Jamo.txt
// Date: Tue May 18 17:24:49 2004
//--------------------------------------------------------------------

// Latin_Jamo

t_Latn_Jamo {
  Rule {
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//--------------------------------------------------------------------

//- 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
  }
}
