Rename: nlg → elp (Engram Language Protocol)
This commit is contained in:
Will Anderson
@@ -0,0 +1,506 @@
|
||||
// morphology-gez.el - Ge'ez morphology for the NLG engine.
|
||||
// ግዕዝ — Classical Ethiopic, the liturgical language of the
|
||||
// Ethiopian Orthodox Church and ancestor of Amharic/Tigrinya.
|
||||
//
|
||||
// Implements Ge'ez verb conjugation (perfect and imperfect, basic G-stem),
|
||||
// noun declension (nominative, accusative, construct; singular and plural),
|
||||
// and noun-phrase construction.
|
||||
//
|
||||
// Ge'ez (also: Classical Ethiopic, gǝʿǝz) is the ancient Semitic language
|
||||
// of the Kingdom of Axum (ca. 300–900 CE active liturgy; ca. 1st century BCE
|
||||
// epigraphic attestation). It remains the liturgical language of the
|
||||
// Ethiopian and Eritrean Orthodox Churches. Modern Ethiopian Semitic languages
|
||||
// (Amharic, Tigrinya, Tigre) descend from Ge'ez or a closely related ancestor.
|
||||
//
|
||||
// Script: Ge'ez Fidel (ፊደል) — an Ethiopic abugida (Unicode U+1200–U+137F).
|
||||
// Each Fidel character encodes a consonant + vowel combination (7 orders per
|
||||
// consonant). String literals in this file use actual Unicode characters.
|
||||
//
|
||||
// NOTE on El runtime: the El VM currently outputs non-ASCII as numeric hashes
|
||||
// (runtime limitation for non-Latin scripts). str_eq and string comparisons
|
||||
// work correctly internally. When the VM adds full UTF-8 output, all Ge'ez
|
||||
// strings will display correctly automatically.
|
||||
//
|
||||
// Language profile:
|
||||
// code=gez, name=Ge'ez, morph_type=semitic, word_order=SOV,
|
||||
// script=ethiopic-fidel, family=semitic/south-ethiopic-semitic
|
||||
//
|
||||
// Key grammatical facts:
|
||||
// - SOV word order — unusual for Semitic (Arabic, Hebrew, Akkadian are VSO);
|
||||
// Ge'ez shares SOV with modern Ethiopian Semitic descendants
|
||||
// - Semitic trilateral root system (root + vowel pattern = word)
|
||||
// - Gender: masculine (default) / feminine (often marked with -t suffix)
|
||||
// - Number: singular / plural; dual vestigial
|
||||
// - Cases: nominative (unmarked), accusative -a (animate masc nouns),
|
||||
// construct/genitive (various; simplified to base form here)
|
||||
// - Plural: no single rule; common patterns: -āt (fem/animate), -ān (masc),
|
||||
// broken (internal vowel change, unpredictable without lexicon)
|
||||
// - Verb system:
|
||||
// Perfect (suffix conjugation): completed action
|
||||
// Imperfect (prefix conjugation): ongoing / future / habitual
|
||||
// Four derived stems: basic (G), causative (ʾa-), intensive (doubling),
|
||||
// passive (te-); this file implements basic G-stem throughout
|
||||
// - No definite article (unlike Amharic which has suffixed -u/-wa/-itu etc.)
|
||||
// - Copula: root kwn (ሆነ honä) — "to be / become"
|
||||
//
|
||||
// Verb conjugation conventions:
|
||||
// person: "first" | "second" | "third"
|
||||
// gender: "m" | "f"
|
||||
// number: "singular" | "plural"
|
||||
// tense: "perfect" | "imperfect"
|
||||
//
|
||||
// Noun declension conventions:
|
||||
// gram_case: "nom" | "acc" | "construct"
|
||||
// number: "singular" | "plural"
|
||||
//
|
||||
// Verbs covered (root / Fidel form / transliteration):
|
||||
// "kwn" / ሆነ (honä) — to be / become (copula)
|
||||
// "hlw" / ሀሎ (hallo) — to exist / there is
|
||||
// "hbl" / ሰጠ (säṭṭä) — to give
|
||||
// "rʾy" / አየ (ʾayyä) — to see
|
||||
// "qwl" / ተናገረ (tänagärä) — to speak
|
||||
//
|
||||
// Depends on: morphology.el (str_eq, str_len, str_slice, str_ends_with)
|
||||
|
||||
// ── String helpers ─────────────────────────────────────────────────────────────
|
||||
|
||||
fn gez_str_ends(s: String, suf: String) -> Bool {
|
||||
return str_ends_with(s, suf)
|
||||
}
|
||||
|
||||
fn gez_str_len(s: String) -> Int {
|
||||
return str_len(s)
|
||||
}
|
||||
|
||||
fn gez_str_drop_last(s: String, n: Int) -> String {
|
||||
let len: Int = str_len(s)
|
||||
if n >= len {
|
||||
return ""
|
||||
}
|
||||
return str_slice(s, 0, len - n)
|
||||
}
|
||||
|
||||
// ── Slot index ─────────────────────────────────────────────────────────────────
|
||||
//
|
||||
// Maps person × number to a 0-based slot for table lookups.
|
||||
// Gender is handled separately for third-person disambiguation.
|
||||
//
|
||||
// Slot layout (6 primary cells):
|
||||
// 0 = 1sg (I)
|
||||
// 1 = 2sg (you sg — gender note: Ge'ez distinguishes 2sg m/f in perfect)
|
||||
// 2 = 3sg m (he)
|
||||
// 3 = 3sg f (she)
|
||||
// 4 = 1pl (we)
|
||||
// 5 = 3pl (they — default masc)
|
||||
|
||||
fn gez_slot(person: String, number: String) -> Int {
|
||||
if str_eq(person, "first") {
|
||||
if str_eq(number, "plural") { return 4 }
|
||||
return 0
|
||||
}
|
||||
if str_eq(person, "second") {
|
||||
return 1
|
||||
}
|
||||
// third
|
||||
if str_eq(number, "plural") { return 5 }
|
||||
return 2
|
||||
}
|
||||
|
||||
// gez_slot_g: gender-sensitive slot for third-person singular.
|
||||
fn gez_slot_g(person: String, gender: String, number: String) -> Int {
|
||||
let base: Int = gez_slot(person, number)
|
||||
if str_eq(person, "third") {
|
||||
if str_eq(number, "singular") {
|
||||
if str_eq(gender, "f") { return 3 }
|
||||
}
|
||||
}
|
||||
return base
|
||||
}
|
||||
|
||||
// ── Copula: kwn / ሆነ — to be / become ────────────────────────────────────────
|
||||
//
|
||||
// Perfect paradigm (suffix forms):
|
||||
// 3sg m: ሆነ honä (base form)
|
||||
// 3sg f: ሆነት honät (-t suffix)
|
||||
// 2sg m: ሆንከ honkä (-kä suffix)
|
||||
// 2sg f: ሆንኪ honki (-ki suffix)
|
||||
// 1sg: ሆንኩ honku (-ku suffix)
|
||||
// 3pl m: ሆኑ honu (-u suffix)
|
||||
// 3pl f: ሆና honā (-ā suffix)
|
||||
// 2pl: ሆንክሙ honkǝmu (-kǝmu suffix)
|
||||
// 1pl: ሆንነ honna (-na suffix)
|
||||
//
|
||||
// Imperfect paradigm (prefix forms):
|
||||
// 3sg m: ይሆን yǝhon (yǝ- prefix)
|
||||
// 3sg f: ትሆን tǝhon (tǝ- prefix)
|
||||
// 2sg: ትሆን tǝhon (tǝ- prefix)
|
||||
// 1sg: እሆን ʾǝhon (ʾǝ- prefix)
|
||||
// 3pl m: ይሆኑ yǝhonu (yǝ- + -u suffix)
|
||||
// 1pl: ንሆን nǝhon (nǝ- prefix)
|
||||
|
||||
fn gez_kwn_perfect(slot: Int) -> String {
|
||||
if slot == 0 { return "ሆንኩ" } // 1sg honku
|
||||
if slot == 1 { return "ሆንከ" } // 2sg m honkä (default; fem: ሆንኪ)
|
||||
if slot == 2 { return "ሆነ" } // 3sg m honä
|
||||
if slot == 3 { return "ሆነት" } // 3sg f honät
|
||||
if slot == 4 { return "ሆንነ" } // 1pl honna
|
||||
return "ሆኑ" // 3pl honu
|
||||
}
|
||||
|
||||
fn gez_kwn_imperfect(slot: Int) -> String {
|
||||
if slot == 0 { return "እሆን" } // 1sg ʾǝhon
|
||||
if slot == 1 { return "ትሆን" } // 2sg tǝhon
|
||||
if slot == 2 { return "ይሆን" } // 3sg m yǝhon
|
||||
if slot == 3 { return "ትሆን" } // 3sg f tǝhon (same prefix as 2sg)
|
||||
if slot == 4 { return "ንሆን" } // 1pl nǝhon
|
||||
return "ይሆኑ" // 3pl yǝhonu
|
||||
}
|
||||
|
||||
fn gez_is_copula(verb: String) -> Bool {
|
||||
if str_eq(verb, "kwn") { return true }
|
||||
if str_eq(verb, "ሆነ") { return true }
|
||||
if str_eq(verb, "hona") { return true }
|
||||
if str_eq(verb, "be") { return true }
|
||||
return false
|
||||
}
|
||||
|
||||
fn gez_conjugate_copula(tense: String, slot: Int) -> String {
|
||||
if str_eq(tense, "imperfect") { return gez_kwn_imperfect(slot) }
|
||||
return gez_kwn_perfect(slot)
|
||||
}
|
||||
|
||||
// ── hlw / ሀሎ — to exist / there is ───────────────────────────────────────────
|
||||
//
|
||||
// hallo is an existential copula used for "there is/are".
|
||||
// In Ge'ez it is largely invariant in its classical usage (presentational).
|
||||
// We provide a minimal paradigm; for existential use, hallo is returned for
|
||||
// all slots in the "perfect" (existential present).
|
||||
|
||||
fn gez_hlw_perfect(slot: Int) -> String {
|
||||
// Invariant existential for most purposes
|
||||
if slot == 0 { return "ሀሎኩ" } // 1sg halloku
|
||||
if slot == 1 { return "ሀሎከ" } // 2sg hallokä
|
||||
if slot == 2 { return "ሀሎ" } // 3sg m hallo
|
||||
if slot == 3 { return "ሀለወት" } // 3sg f halläwät
|
||||
if slot == 4 { return "ሀሎነ" } // 1pl hallonä
|
||||
return "ሀሉ" // 3pl hallu
|
||||
}
|
||||
|
||||
fn gez_hlw_imperfect(slot: Int) -> String {
|
||||
if slot == 0 { return "እሀሉ" } // 1sg
|
||||
if slot == 1 { return "ትሀሉ" } // 2sg
|
||||
if slot == 2 { return "ይሀሉ" } // 3sg m
|
||||
if slot == 3 { return "ትሀሉ" } // 3sg f
|
||||
if slot == 4 { return "ንሀሉ" } // 1pl
|
||||
return "ይሀልዉ" // 3pl
|
||||
}
|
||||
|
||||
// ── hbl / ሰጠ — to give ────────────────────────────────────────────────────────
|
||||
//
|
||||
// Perfect: säṭṭä (3sg m base); standard G-stem suffix paradigm.
|
||||
// Imperfect: yǝsäṭ (3sg m).
|
||||
|
||||
fn gez_hbl_perfect(slot: Int) -> String {
|
||||
if slot == 0 { return "ሰጠኩ" } // 1sg säṭṭäku
|
||||
if slot == 1 { return "ሰጠከ" } // 2sg säṭṭäkä
|
||||
if slot == 2 { return "ሰጠ" } // 3sg m säṭṭä
|
||||
if slot == 3 { return "ሰጠት" } // 3sg f säṭṭät
|
||||
if slot == 4 { return "ሰጠነ" } // 1pl säṭṭänä
|
||||
return "ሰጡ" // 3pl säṭṭu
|
||||
}
|
||||
|
||||
fn gez_hbl_imperfect(slot: Int) -> String {
|
||||
if slot == 0 { return "እሰጥ" } // 1sg ʾǝsäṭ
|
||||
if slot == 1 { return "ትሰጥ" } // 2sg tǝsäṭ
|
||||
if slot == 2 { return "ይሰጥ" } // 3sg m yǝsäṭ
|
||||
if slot == 3 { return "ትሰጥ" } // 3sg f tǝsäṭ
|
||||
if slot == 4 { return "ንሰጥ" } // 1pl nǝsäṭ
|
||||
return "ይሰጡ" // 3pl yǝsäṭu
|
||||
}
|
||||
|
||||
// ── rʾy / አየ — to see ─────────────────────────────────────────────────────────
|
||||
//
|
||||
// Third-weak verb (final ʾ). Perfect: ʾayyä (3sg m); imperfect: yāy (3sg m).
|
||||
|
||||
fn gez_ray_perfect(slot: Int) -> String {
|
||||
if slot == 0 { return "አየኩ" } // 1sg ʾayyäku
|
||||
if slot == 1 { return "አየከ" } // 2sg ʾayyäkä
|
||||
if slot == 2 { return "አየ" } // 3sg m ʾayyä
|
||||
if slot == 3 { return "አየት" } // 3sg f ʾayyät
|
||||
if slot == 4 { return "አየነ" } // 1pl ʾayyänä
|
||||
return "አዩ" // 3pl ʾayyu
|
||||
}
|
||||
|
||||
fn gez_ray_imperfect(slot: Int) -> String {
|
||||
if slot == 0 { return "እያይ" } // 1sg ʾǝyāy
|
||||
if slot == 1 { return "ትያይ" } // 2sg tǝyāy
|
||||
if slot == 2 { return "ያይ" } // 3sg m yāy
|
||||
if slot == 3 { return "ትያይ" } // 3sg f tǝyāy
|
||||
if slot == 4 { return "ንያይ" } // 1pl nǝyāy
|
||||
return "ያዩ" // 3pl yāyu
|
||||
}
|
||||
|
||||
// ── qwl / ተናገረ — to speak ────────────────────────────────────────────────────
|
||||
//
|
||||
// tänagärä is actually a derived (reciprocal / D-stem) form of the root ngrǝ,
|
||||
// used as the ordinary word for "to speak" in Classical Ge'ez.
|
||||
// Perfect: tänagärä (3sg m); imperfect: yǝnagär (3sg m).
|
||||
|
||||
fn gez_qwl_perfect(slot: Int) -> String {
|
||||
if slot == 0 { return "ተናገርኩ" } // 1sg tänagärku
|
||||
if slot == 1 { return "ተናገርከ" } // 2sg tänagärkä
|
||||
if slot == 2 { return "ተናገረ" } // 3sg m tänagärä
|
||||
if slot == 3 { return "ተናገረት" } // 3sg f tänagärät
|
||||
if slot == 4 { return "ተናገርነ" } // 1pl tänagärnä
|
||||
return "ተናገሩ" // 3pl tänagäru
|
||||
}
|
||||
|
||||
fn gez_qwl_imperfect(slot: Int) -> String {
|
||||
if slot == 0 { return "እናገር" } // 1sg ʾǝnagär
|
||||
if slot == 1 { return "ትናገር" } // 2sg tǝnagär
|
||||
if slot == 2 { return "ይናገር" } // 3sg m yǝnagär
|
||||
if slot == 3 { return "ትናገር" } // 3sg f tǝnagär
|
||||
if slot == 4 { return "ንናገር" } // 1pl nǝnagär
|
||||
return "ይናገሩ" // 3pl yǝnagäru
|
||||
}
|
||||
|
||||
// ── Generic G-stem paradigm ────────────────────────────────────────────────────
|
||||
//
|
||||
// For regular strong verbs not in the lookup table.
|
||||
// Ge'ez perfect suffixes: 1sg -ku, 2sg -kä, 3sg m ∅, 3sg f -at, 1pl -nä, 3pl -u
|
||||
// Ge'ez imperfect prefixes: 1sg ʾǝ-, 2sg tǝ-, 3sg m yǝ-, 3sg f tǝ-, 1pl nǝ-
|
||||
|
||||
fn gez_generic_perfect(base3sg: String, slot: Int) -> String {
|
||||
if slot == 0 { return base3sg + "ኩ" } // -ku
|
||||
if slot == 1 { return base3sg + "ከ" } // -kä
|
||||
if slot == 2 { return base3sg } // ∅
|
||||
if slot == 3 { return base3sg + "ት" } // -at (simplified: -t Fidel)
|
||||
if slot == 4 { return base3sg + "ነ" } // -nä
|
||||
return base3sg + "ኡ" // -u (3pl)
|
||||
}
|
||||
|
||||
fn gez_generic_imperfect(base3sg: String, slot: Int) -> String {
|
||||
// base3sg is the 3sg m imperfect form (with yǝ- prefix)
|
||||
// We heuristically return the stem with different prefixes.
|
||||
if slot == 0 { return "እ" + base3sg } // ʾǝ-
|
||||
if slot == 1 { return "ት" + base3sg } // tǝ-
|
||||
if slot == 2 { return "ይ" + base3sg } // yǝ-
|
||||
if slot == 3 { return "ት" + base3sg } // tǝ-
|
||||
if slot == 4 { return "ን" + base3sg } // nǝ-
|
||||
return "ይ" + base3sg + "ኡ" // yǝ- + -u (3pl)
|
||||
}
|
||||
|
||||
// ── Known-verb dispatcher ─────────────────────────────────────────────────────
|
||||
|
||||
fn gez_known_verb(verb: String, tense: String, slot: Int) -> String {
|
||||
// kwn / ሆነ — to be
|
||||
if str_eq(verb, "kwn") {
|
||||
return gez_conjugate_copula(tense, slot)
|
||||
}
|
||||
if str_eq(verb, "ሆነ") {
|
||||
return gez_conjugate_copula(tense, slot)
|
||||
}
|
||||
if str_eq(verb, "hona") {
|
||||
return gez_conjugate_copula(tense, slot)
|
||||
}
|
||||
|
||||
// hlw / ሀሎ — to exist
|
||||
if str_eq(verb, "hlw") {
|
||||
if str_eq(tense, "imperfect") { return gez_hlw_imperfect(slot) }
|
||||
return gez_hlw_perfect(slot)
|
||||
}
|
||||
if str_eq(verb, "ሀሎ") {
|
||||
if str_eq(tense, "imperfect") { return gez_hlw_imperfect(slot) }
|
||||
return gez_hlw_perfect(slot)
|
||||
}
|
||||
if str_eq(verb, "hallo") {
|
||||
if str_eq(tense, "imperfect") { return gez_hlw_imperfect(slot) }
|
||||
return gez_hlw_perfect(slot)
|
||||
}
|
||||
|
||||
// hbl / ሰጠ — to give
|
||||
if str_eq(verb, "hbl") {
|
||||
if str_eq(tense, "imperfect") { return gez_hbl_imperfect(slot) }
|
||||
return gez_hbl_perfect(slot)
|
||||
}
|
||||
if str_eq(verb, "ሰጠ") {
|
||||
if str_eq(tense, "imperfect") { return gez_hbl_imperfect(slot) }
|
||||
return gez_hbl_perfect(slot)
|
||||
}
|
||||
if str_eq(verb, "sätta") {
|
||||
if str_eq(tense, "imperfect") { return gez_hbl_imperfect(slot) }
|
||||
return gez_hbl_perfect(slot)
|
||||
}
|
||||
|
||||
// rʾy / አየ — to see
|
||||
if str_eq(verb, "rʾy") {
|
||||
if str_eq(tense, "imperfect") { return gez_ray_imperfect(slot) }
|
||||
return gez_ray_perfect(slot)
|
||||
}
|
||||
if str_eq(verb, "አየ") {
|
||||
if str_eq(tense, "imperfect") { return gez_ray_imperfect(slot) }
|
||||
return gez_ray_perfect(slot)
|
||||
}
|
||||
if str_eq(verb, "ʾayya") {
|
||||
if str_eq(tense, "imperfect") { return gez_ray_imperfect(slot) }
|
||||
return gez_ray_perfect(slot)
|
||||
}
|
||||
|
||||
// qwl / ተናገረ — to speak
|
||||
if str_eq(verb, "qwl") {
|
||||
if str_eq(tense, "imperfect") { return gez_qwl_imperfect(slot) }
|
||||
return gez_qwl_perfect(slot)
|
||||
}
|
||||
if str_eq(verb, "ተናገረ") {
|
||||
if str_eq(tense, "imperfect") { return gez_qwl_imperfect(slot) }
|
||||
return gez_qwl_perfect(slot)
|
||||
}
|
||||
if str_eq(verb, "tänagärä") {
|
||||
if str_eq(tense, "imperfect") { return gez_qwl_imperfect(slot) }
|
||||
return gez_qwl_perfect(slot)
|
||||
}
|
||||
|
||||
return ""
|
||||
}
|
||||
|
||||
// ── Main conjugation entry point ──────────────────────────────────────────────
|
||||
//
|
||||
// gez_conjugate: conjugate a Ge'ez verb (G-stem / basic stem).
|
||||
//
|
||||
// verb: root (e.g. "kwn", "rʾy"), Fidel citation form (e.g. "ሆነ"),
|
||||
// or transliterated 3sg perfect (e.g. "hona", "ʾayya")
|
||||
// tense: "perfect" | "imperfect"
|
||||
// person: "first" | "second" | "third"
|
||||
// number: "singular" | "plural"
|
||||
//
|
||||
// Returns:
|
||||
// - Fidel string (Unicode) for known verbs
|
||||
// - verb unchanged as safe fallback for unknown verbs
|
||||
|
||||
fn gez_conjugate(verb: String, tense: String, person: String, number: String) -> String {
|
||||
let slot: Int = gez_slot(person, number)
|
||||
|
||||
if gez_is_copula(verb) {
|
||||
return gez_conjugate_copula(tense, slot)
|
||||
}
|
||||
|
||||
let known: String = gez_known_verb(verb, tense, slot)
|
||||
if !str_eq(known, "") {
|
||||
return known
|
||||
}
|
||||
|
||||
return verb
|
||||
}
|
||||
|
||||
// ── Noun declension ────────────────────────────────────────────────────────────
|
||||
//
|
||||
// gez_decline: decline a Ge'ez noun for gram_case and number.
|
||||
//
|
||||
// Case system (simplified for this engine):
|
||||
// Nominative: base form (unmarked — the Fidel form as given)
|
||||
// Accusative: base + -a (for animate masculine nouns; inanimate often same)
|
||||
// Construct: base form (genitive/construct; detailed vowel alternations
|
||||
// are lexically irregular — simplified to base here)
|
||||
//
|
||||
// Plural patterns (highly irregular in Ge'ez, like Arabic broken plurals):
|
||||
// Common productive suffixes:
|
||||
// Feminine/animate: -āt (ሀዋርያት hawāryāt — apostles)
|
||||
// Masculine: -ān (ነቢያን nabiyān — prophets)
|
||||
// Broken plurals: unpredictable — must come from vocabulary layer.
|
||||
// Fallback: base + "āt" (ア default)
|
||||
//
|
||||
// noun: base singular form (Fidel or transliterated)
|
||||
// gram_case: "nom" | "acc" | "construct"
|
||||
// number: "singular" | "plural"
|
||||
|
||||
fn gez_is_fidel(noun: String) -> Bool {
|
||||
// Ethiopic Unicode block starts at U+1200 (ሀ).
|
||||
// We detect by checking a set of common Fidel first characters.
|
||||
let n: Int = gez_str_len(noun)
|
||||
if n == 0 { return false }
|
||||
let first: String = str_slice(noun, 0, 1)
|
||||
if str_eq(first, "ሀ") { return true }
|
||||
if str_eq(first, "ሁ") { return true }
|
||||
if str_eq(first, "ሂ") { return true }
|
||||
if str_eq(first, "ሃ") { return true }
|
||||
if str_eq(first, "ሄ") { return true }
|
||||
if str_eq(first, "ህ") { return true }
|
||||
if str_eq(first, "ሆ") { return true }
|
||||
if str_eq(first, "ለ") { return true }
|
||||
if str_eq(first, "መ") { return true }
|
||||
if str_eq(first, "ሰ") { return true }
|
||||
if str_eq(first, "ሸ") { return true }
|
||||
if str_eq(first, "ቀ") { return true }
|
||||
if str_eq(first, "በ") { return true }
|
||||
if str_eq(first, "ተ") { return true }
|
||||
if str_eq(first, "ነ") { return true }
|
||||
if str_eq(first, "አ") { return true }
|
||||
if str_eq(first, "እ") { return true }
|
||||
if str_eq(first, "ከ") { return true }
|
||||
if str_eq(first, "ወ") { return true }
|
||||
if str_eq(first, "ዘ") { return true }
|
||||
if str_eq(first, "የ") { return true }
|
||||
if str_eq(first, "ደ") { return true }
|
||||
if str_eq(first, "ገ") { return true }
|
||||
if str_eq(first, "ጠ") { return true }
|
||||
if str_eq(first, "ፀ") { return true }
|
||||
if str_eq(first, "ፈ") { return true }
|
||||
if str_eq(first, "ፐ") { return true }
|
||||
return false
|
||||
}
|
||||
|
||||
fn gez_decline(noun: String, gram_case: String, number: String) -> String {
|
||||
if str_eq(number, "plural") {
|
||||
// Plural: default suffix -āt (Fidel: append transliterated marker for
|
||||
// non-Fidel input; for Fidel input append ት as the -āt marker)
|
||||
if gez_is_fidel(noun) {
|
||||
return noun + "ዎች" // simplified -woc plural marker (Ge'ez -āt ≈ ዎ)
|
||||
}
|
||||
return noun + "āt"
|
||||
}
|
||||
|
||||
// Singular
|
||||
if str_eq(gram_case, "acc") {
|
||||
// Accusative: add -a suffix
|
||||
if gez_is_fidel(noun) {
|
||||
return noun + "ን" // accusative object marker (simplified)
|
||||
}
|
||||
return noun + "a"
|
||||
}
|
||||
|
||||
// Nominative and construct: return base form
|
||||
return noun
|
||||
}
|
||||
|
||||
// ── Noun phrase ────────────────────────────────────────────────────────────────
|
||||
//
|
||||
// gez_noun_phrase: produce the surface noun phrase.
|
||||
//
|
||||
// Ge'ez has no definite article (unlike Amharic's suffix -u/-wa/-itu).
|
||||
// Definiteness is expressed through word order and context.
|
||||
// The definite parameter is accepted for interface uniformity but has no
|
||||
// surface effect.
|
||||
//
|
||||
// noun: base noun (Fidel string or transliteration)
|
||||
// gram_case: "nom" | "acc" | "construct"
|
||||
// number: "singular" | "plural"
|
||||
// definite: "true" | "false" (no surface effect in Ge'ez)
|
||||
|
||||
fn gez_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String {
|
||||
return gez_decline(noun, gram_case, number)
|
||||
}
|
||||
|
||||
// ── Canonical verb mapping ─────────────────────────────────────────────────────
|
||||
//
|
||||
// gez_map_canonical: map cross-lingual English canonical verb labels to
|
||||
// Ge'ez roots or citation forms.
|
||||
|
||||
fn gez_map_canonical(verb: String) -> String {
|
||||
if str_eq(verb, "be") { return "kwn" }
|
||||
if str_eq(verb, "exist") { return "hlw" }
|
||||
if str_eq(verb, "give") { return "hbl" }
|
||||
if str_eq(verb, "see") { return "rʾy" }
|
||||
if str_eq(verb, "speak") { return "qwl" }
|
||||
if str_eq(verb, "say") { return "qwl" }
|
||||
return verb
|
||||
}
|
||||
Reference in New Issue
Block a user