Rename: nlg → elp (Engram Language Protocol)
This commit is contained in:
Will Anderson
@@ -0,0 +1,570 @@
|
||||
// morphology-egy.el - Ancient Egyptian (Middle Egyptian) morphology for the NLG engine.
|
||||
//
|
||||
// Implements Middle Egyptian verb conjugation (sdm=f / sdm.n=f paradigm),
|
||||
// noun number marking, suffix pronouns, and noun phrase assembly.
|
||||
// Designed as a companion to morphology.el; called when language code is "egy".
|
||||
//
|
||||
// Language profile: code=egy, name=Ancient Egyptian, morph_type=agglutinative,
|
||||
// word_order=SVO (Middle Egyptian nominal sentences), question_strategy=particle,
|
||||
// script=hieroglyphic (transliterated here as ASCII), family=afro-asiatic-egyptian.
|
||||
//
|
||||
// Script note: Classical transliteration uses special characters (ꜣ ꜥ ḥ ḫ ẖ š q ṯ ḏ).
|
||||
// This engine uses a safe ASCII mapping:
|
||||
// A = ꜣ (aleph/glottal stop) a = ꜥ (ayin)
|
||||
// H = ḥ (h with dot) x = ḫ (velar fricative)
|
||||
// X = ẖ (emphatic h) sh = š (sh sound)
|
||||
// q = q (emphatic k) T = ṯ (tj sound)
|
||||
// D = ḏ (dj sound)
|
||||
// This mapping keeps all string literals ASCII-safe for the El runtime.
|
||||
//
|
||||
// Grammatical notes (Middle Egyptian, ca. 2000–1300 BCE):
|
||||
// - Aspectual system: Imperfective (sdm=f), Perfective (sdm.n=f), Prospective
|
||||
// - "tense" labels used here: "present" (imperfective), "past" (perfective),
|
||||
// "future" (prospective/sdm.xr=f), "infinitive"
|
||||
// - Two grammatical genders: masculine (unmarked) and feminine (suffix -t)
|
||||
// - Number: singular (unmarked), dual (-wy masc / -ty fem), plural (-w masc / -wt fem)
|
||||
// - No case endings — syntactic role expressed by word order and prepositions
|
||||
// - No definite/indefinite article in Middle Egyptian (Late Egyptian introduced pꜣ/tꜣ/nꜣ)
|
||||
// - Zero copula: adjectival predicates need no verb "to be" ("nfr sw" = "he is good")
|
||||
// - Suffix pronouns attach directly to the verb stem with = (e.g. sdm=f "he hears")
|
||||
//
|
||||
// Persons/numbers covered (suffix pronoun paradigm):
|
||||
// person: "first" | "second" | "third"
|
||||
// gender: "m" | "f" (relevant for 2sg, 3sg; 1sg and plurals often unmarked)
|
||||
// number: "singular" | "dual" | "plural"
|
||||
//
|
||||
// Verbs covered (ASCII transliteration → gloss):
|
||||
// wnn — to be/exist (copular auxiliary)
|
||||
// rdi / di — to give
|
||||
// mAA — to see
|
||||
// Dd — to say
|
||||
// Sm — to go
|
||||
// iri — to do / make
|
||||
// sdm — to hear (the paradigm verb for the sdm=f construction)
|
||||
//
|
||||
// Canonical English → Egyptian mapping:
|
||||
// "be" → wnn / zero copula "give" → rdi
|
||||
// "see" → mAA "say" → Dd
|
||||
// "go" → Sm "do" → iri
|
||||
// "make" → iri "hear" → sdm
|
||||
//
|
||||
// Depends on: morphology.el (str_eq, str_len, str_slice, str_ends_with)
|
||||
|
||||
// ── String helpers ──────────────────────────────────────────────────────────────
|
||||
|
||||
fn egy_str_ends(s: String, suf: String) -> Bool {
|
||||
return str_ends_with(s, suf)
|
||||
}
|
||||
|
||||
fn egy_str_len(s: String) -> Int {
|
||||
return str_len(s)
|
||||
}
|
||||
|
||||
fn egy_drop(s: String, n: Int) -> String {
|
||||
let len: Int = str_len(s)
|
||||
if n >= len { return "" }
|
||||
return str_slice(s, 0, len - n)
|
||||
}
|
||||
|
||||
fn egy_last_char(s: String) -> String {
|
||||
let n: Int = str_len(s)
|
||||
if n == 0 { return "" }
|
||||
return str_slice(s, n - 1, n)
|
||||
}
|
||||
|
||||
// ── Person/number slot ──────────────────────────────────────────────────────────
|
||||
//
|
||||
// Maps person × gender × number to a 0-based index used in paradigm tables.
|
||||
// Egyptian suffix pronouns distinguish gender in 2nd and 3rd person singular.
|
||||
//
|
||||
// Slot layout:
|
||||
// 0 = 1sg (=i)
|
||||
// 1 = 2sg masc (=k)
|
||||
// 2 = 2sg fem (=T)
|
||||
// 3 = 3sg masc (=f)
|
||||
// 4 = 3sg fem (=s)
|
||||
// 5 = 1pl (=n)
|
||||
// 6 = 2pl (=Tn)
|
||||
// 7 = 3pl (=sn)
|
||||
// 8 = 1du / 2du / 3du (=sny — simplified; dual pronouns are rare in sources)
|
||||
//
|
||||
// Dual falls through to slot 8 (a single dual pronoun slot for all persons).
|
||||
|
||||
fn egy_slot(person: String, number: String) -> Int {
|
||||
if str_eq(number, "dual") { return 8 }
|
||||
if str_eq(person, "first") {
|
||||
if str_eq(number, "plural") { return 5 }
|
||||
return 0
|
||||
}
|
||||
if str_eq(person, "second") {
|
||||
if str_eq(number, "plural") { return 6 }
|
||||
return 1
|
||||
}
|
||||
// third person
|
||||
if str_eq(number, "plural") { return 7 }
|
||||
return 3
|
||||
}
|
||||
|
||||
// egy_slot_with_gender: slot variant that factors in gender for 2sg and 3sg.
|
||||
|
||||
fn egy_slot_with_gender(person: String, gender: String, number: String) -> Int {
|
||||
if str_eq(number, "dual") { return 8 }
|
||||
if str_eq(person, "first") {
|
||||
if str_eq(number, "plural") { return 5 }
|
||||
return 0
|
||||
}
|
||||
if str_eq(person, "second") {
|
||||
if str_eq(number, "plural") { return 6 }
|
||||
if str_eq(gender, "f") { return 2 }
|
||||
return 1
|
||||
}
|
||||
// third person
|
||||
if str_eq(number, "plural") { return 7 }
|
||||
if str_eq(gender, "f") { return 4 }
|
||||
return 3
|
||||
}
|
||||
|
||||
// ── Suffix pronouns ─────────────────────────────────────────────────────────────
|
||||
//
|
||||
// Egyptian suffix pronouns attach to verbs, nouns, and prepositions.
|
||||
// Written with = before the pronoun in transliteration (e.g. =f = "his / he").
|
||||
//
|
||||
// Standard Middle Egyptian paradigm:
|
||||
// 1sg: =i ("I / me / my")
|
||||
// 2sg m: =k ("you / your" masc)
|
||||
// 2sg f: =T ("you / your" fem, ṯ in classical)
|
||||
// 3sg m: =f ("he / him / his")
|
||||
// 3sg f: =s ("she / her")
|
||||
// 1pl: =n ("we / us / our")
|
||||
// 2pl: =Tn ("you all / your" plural)
|
||||
// 3pl: =sn ("they / them / their")
|
||||
// dual: =sny (simplified dual — rare in Middle Egyptian texts)
|
||||
|
||||
fn egy_conjugate_pronoun(person: String, number: String) -> String {
|
||||
let slot: Int = egy_slot(person, number)
|
||||
if slot == 0 { return "=i" }
|
||||
if slot == 1 { return "=k" }
|
||||
if slot == 5 { return "=n" }
|
||||
if slot == 6 { return "=Tn" }
|
||||
if slot == 7 { return "=sn" }
|
||||
if slot == 8 { return "=sny" }
|
||||
// slots 2–4 need gender; default to masc for slot 3
|
||||
return "=f"
|
||||
}
|
||||
|
||||
fn egy_suffix_pronoun(slot: Int) -> String {
|
||||
if slot == 0 { return "=i" }
|
||||
if slot == 1 { return "=k" }
|
||||
if slot == 2 { return "=T" }
|
||||
if slot == 3 { return "=f" }
|
||||
if slot == 4 { return "=s" }
|
||||
if slot == 5 { return "=n" }
|
||||
if slot == 6 { return "=Tn" }
|
||||
if slot == 7 { return "=sn" }
|
||||
// dual (slot 8)
|
||||
return "=sny"
|
||||
}
|
||||
|
||||
// ── Copula detection ────────────────────────────────────────────────────────────
|
||||
//
|
||||
// In Middle Egyptian the verb "to be" as predicate is often omitted in the
|
||||
// present (zero copula for adjective predicates). The auxiliary wnn is used
|
||||
// for existence / substantive "to be" and in subordinate clauses.
|
||||
// Canonical English label "be" maps to zero copula in the present.
|
||||
|
||||
fn egy_is_copula(verb: String) -> Bool {
|
||||
if str_eq(verb, "wnn") { return true }
|
||||
if str_eq(verb, "be") { return true }
|
||||
return false
|
||||
}
|
||||
|
||||
// ── Copula conjugation ──────────────────────────────────────────────────────────
|
||||
//
|
||||
// Present ("imperfective"): zero copula for adjectival predicate — return "".
|
||||
// The auxiliary iw...wnn is used in certain syntactic environments but the
|
||||
// bare zero is the canonical Middle Egyptian form.
|
||||
// Past ("perfective"): wnn.n (with perfective suffix .n)
|
||||
// Future ("prospective"): wnn.xr (prospective form, simplified)
|
||||
|
||||
fn egy_conjugate_copula(tense: String, slot: Int) -> String {
|
||||
if str_eq(tense, "present") { return "" }
|
||||
if str_eq(tense, "past") {
|
||||
return "wnn.n" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
if str_eq(tense, "future") {
|
||||
return "wnn.xr" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
if str_eq(tense, "infinitive") { return "wnn" }
|
||||
// Default: zero copula
|
||||
return ""
|
||||
}
|
||||
|
||||
// ── Irregular verb: rdi / di (to give) ─────────────────────────────────────────
|
||||
//
|
||||
// rdi is the full form; di is the common abbreviated written form.
|
||||
// Imperfective (present): di=f (3sg m), with full pronoun for other persons.
|
||||
// Perfective (past): di.n=f
|
||||
// Prospective (future): di.xr=f
|
||||
// Infinitive: rdi
|
||||
|
||||
fn egy_rdi_present(slot: Int) -> String {
|
||||
return "di" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_rdi_past(slot: Int) -> String {
|
||||
return "di.n" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_rdi_future(slot: Int) -> String {
|
||||
return "di.xr" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
// ── Irregular verb: mAA (to see) ───────────────────────────────────────────────
|
||||
//
|
||||
// mAA is a geminated root (m-AA).
|
||||
// Present: mAA=f; Past: mAA.n=f; Future: mAA.xr=f
|
||||
|
||||
fn egy_mAA_present(slot: Int) -> String {
|
||||
return "mAA" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_mAA_past(slot: Int) -> String {
|
||||
return "mAA.n" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_mAA_future(slot: Int) -> String {
|
||||
return "mAA.xr" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
// ── Irregular verb: Dd (to say) ─────────────────────────────────────────────────
|
||||
//
|
||||
// Present: Dd=f; Past: Dd.n=f; Future: Dd.xr=f
|
||||
// Infinitive: Dd
|
||||
|
||||
fn egy_Dd_present(slot: Int) -> String {
|
||||
return "Dd" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_Dd_past(slot: Int) -> String {
|
||||
return "Dd.n" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_Dd_future(slot: Int) -> String {
|
||||
return "Dd.xr" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
// ── Irregular verb: Sm (to go) ─────────────────────────────────────────────────
|
||||
//
|
||||
// Present: Sm=f; Past: Sm.n=f; Future: Sm.xr=f
|
||||
// (Note: the verb Smt "to go" appears in texts; Sm is the most common short form.)
|
||||
|
||||
fn egy_Sm_present(slot: Int) -> String {
|
||||
return "Sm" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_Sm_past(slot: Int) -> String {
|
||||
return "Sm.n" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_Sm_future(slot: Int) -> String {
|
||||
return "Sm.xr" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
// ── Irregular verb: iri (to do / make) ─────────────────────────────────────────
|
||||
//
|
||||
// iri has a contracted 3-radical stem ir- before pronouns.
|
||||
// Present: ir=f; Past: ir.n=f; Future: ir.xr=f
|
||||
// Infinitive: iri
|
||||
|
||||
fn egy_iri_present(slot: Int) -> String {
|
||||
return "ir" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_iri_past(slot: Int) -> String {
|
||||
return "ir.n" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_iri_future(slot: Int) -> String {
|
||||
return "ir.xr" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
// ── Regular verb: sdm (to hear) ────────────────────────────────────────────────
|
||||
//
|
||||
// sdm (to hear) is the paradigm verb used in grammar textbooks to illustrate
|
||||
// all Egyptian verb forms. The sdm=f construction names the imperfective suffix
|
||||
// verb pattern itself.
|
||||
// Present: sdm=f; Past: sdm.n=f; Future: sdm.xr=f
|
||||
// Infinitive: sdm
|
||||
|
||||
fn egy_sdm_present(slot: Int) -> String {
|
||||
return "sdm" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_sdm_past(slot: Int) -> String {
|
||||
return "sdm.n" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_sdm_future(slot: Int) -> String {
|
||||
return "sdm.xr" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
// ── Known-verb dispatcher ───────────────────────────────────────────────────────
|
||||
//
|
||||
// Returns the inflected form for a known verb, or "" if unknown.
|
||||
// Accepts both canonical English labels and Egyptian transliterations.
|
||||
|
||||
fn egy_known_verb(verb: String, tense: String, slot: Int) -> String {
|
||||
// ── rdi / di — to give ───────────────────────────────────────────────────────
|
||||
if str_eq(verb, "rdi") {
|
||||
if str_eq(tense, "present") { return egy_rdi_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_rdi_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_rdi_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "rdi" }
|
||||
return egy_rdi_present(slot)
|
||||
}
|
||||
if str_eq(verb, "di") {
|
||||
if str_eq(tense, "present") { return egy_rdi_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_rdi_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_rdi_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "rdi" }
|
||||
return egy_rdi_present(slot)
|
||||
}
|
||||
if str_eq(verb, "give") {
|
||||
if str_eq(tense, "present") { return egy_rdi_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_rdi_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_rdi_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "rdi" }
|
||||
return egy_rdi_present(slot)
|
||||
}
|
||||
|
||||
// ── mAA — to see ─────────────────────────────────────────────────────────────
|
||||
if str_eq(verb, "mAA") {
|
||||
if str_eq(tense, "present") { return egy_mAA_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_mAA_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_mAA_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "mAA" }
|
||||
return egy_mAA_present(slot)
|
||||
}
|
||||
if str_eq(verb, "see") {
|
||||
if str_eq(tense, "present") { return egy_mAA_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_mAA_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_mAA_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "mAA" }
|
||||
return egy_mAA_present(slot)
|
||||
}
|
||||
|
||||
// ── Dd — to say ──────────────────────────────────────────────────────────────
|
||||
if str_eq(verb, "Dd") {
|
||||
if str_eq(tense, "present") { return egy_Dd_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_Dd_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_Dd_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "Dd" }
|
||||
return egy_Dd_present(slot)
|
||||
}
|
||||
if str_eq(verb, "say") {
|
||||
if str_eq(tense, "present") { return egy_Dd_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_Dd_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_Dd_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "Dd" }
|
||||
return egy_Dd_present(slot)
|
||||
}
|
||||
|
||||
// ── Sm — to go ───────────────────────────────────────────────────────────────
|
||||
if str_eq(verb, "Sm") {
|
||||
if str_eq(tense, "present") { return egy_Sm_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_Sm_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_Sm_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "Sm" }
|
||||
return egy_Sm_present(slot)
|
||||
}
|
||||
if str_eq(verb, "go") {
|
||||
if str_eq(tense, "present") { return egy_Sm_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_Sm_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_Sm_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "Sm" }
|
||||
return egy_Sm_present(slot)
|
||||
}
|
||||
|
||||
// ── iri — to do / make ───────────────────────────────────────────────────────
|
||||
if str_eq(verb, "iri") {
|
||||
if str_eq(tense, "present") { return egy_iri_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_iri_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_iri_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "iri" }
|
||||
return egy_iri_present(slot)
|
||||
}
|
||||
if str_eq(verb, "do") {
|
||||
if str_eq(tense, "present") { return egy_iri_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_iri_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_iri_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "iri" }
|
||||
return egy_iri_present(slot)
|
||||
}
|
||||
if str_eq(verb, "make") {
|
||||
if str_eq(tense, "present") { return egy_iri_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_iri_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_iri_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "iri" }
|
||||
return egy_iri_present(slot)
|
||||
}
|
||||
|
||||
// ── sdm — to hear ────────────────────────────────────────────────────────────
|
||||
if str_eq(verb, "sdm") {
|
||||
if str_eq(tense, "present") { return egy_sdm_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_sdm_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_sdm_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "sdm" }
|
||||
return egy_sdm_present(slot)
|
||||
}
|
||||
if str_eq(verb, "hear") {
|
||||
if str_eq(tense, "present") { return egy_sdm_present(slot) }
|
||||
if str_eq(tense, "past") { return egy_sdm_past(slot) }
|
||||
if str_eq(tense, "future") { return egy_sdm_future(slot) }
|
||||
if str_eq(tense, "infinitive") { return "sdm" }
|
||||
return egy_sdm_present(slot)
|
||||
}
|
||||
|
||||
// Verb not in table
|
||||
return ""
|
||||
}
|
||||
|
||||
// ── Regular verb conjugation ────────────────────────────────────────────────────
|
||||
//
|
||||
// For verbs not in the explicit table, apply the productive suffix-verb pattern:
|
||||
// Present (imperfective sdm=f): stem + pronoun suffix
|
||||
// Past (perfective sdm.n=f): stem + ".n" + pronoun suffix
|
||||
// Future (prospective sdm.xr=f): stem + ".xr" + pronoun suffix
|
||||
// Infinitive: stem unchanged
|
||||
//
|
||||
// This covers the vast majority of strong (sound) verb roots.
|
||||
|
||||
fn egy_regular_present(stem: String, slot: Int) -> String {
|
||||
return stem + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_regular_past(stem: String, slot: Int) -> String {
|
||||
return stem + ".n" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
fn egy_regular_future(stem: String, slot: Int) -> String {
|
||||
return stem + ".xr" + egy_suffix_pronoun(slot)
|
||||
}
|
||||
|
||||
// ── egy_conjugate: main conjugation entry point ─────────────────────────────────
|
||||
//
|
||||
// verb: Egyptian verb (ASCII transliteration) or English canonical label
|
||||
// tense: "present" | "past" | "future" | "infinitive"
|
||||
// person: "first" | "second" | "third"
|
||||
// number: "singular" | "dual" | "plural"
|
||||
//
|
||||
// Returns:
|
||||
// - "" for present copula (zero copula — caller omits the verb)
|
||||
// - inflected form (stem + .n + suffix, etc.) for all other cases
|
||||
// - verb + regular suffix for unknown verbs (productive fallback)
|
||||
|
||||
fn egy_conjugate(verb: String, tense: String, person: String, number: String) -> String {
|
||||
let slot: Int = egy_slot(person, number)
|
||||
|
||||
// Handle copula (wnn / "be")
|
||||
if egy_is_copula(verb) {
|
||||
return egy_conjugate_copula(tense, slot)
|
||||
}
|
||||
|
||||
// Try the known-verb table
|
||||
let known: String = egy_known_verb(verb, tense, slot)
|
||||
if !str_eq(known, "") {
|
||||
return known
|
||||
}
|
||||
|
||||
// Infinitive: return unchanged
|
||||
if str_eq(tense, "infinitive") { return verb }
|
||||
|
||||
// Regular verb: apply productive sdm=f / sdm.n=f pattern
|
||||
if str_eq(tense, "present") { return egy_regular_present(verb, slot) }
|
||||
if str_eq(tense, "past") { return egy_regular_past(verb, slot) }
|
||||
if str_eq(tense, "future") { return egy_regular_future(verb, slot) }
|
||||
|
||||
// Unknown tense: return verb unchanged as safe fallback
|
||||
return verb
|
||||
}
|
||||
|
||||
// ── Noun number marking ─────────────────────────────────────────────────────────
|
||||
//
|
||||
// Middle Egyptian nouns are invariant for case — syntactic role is expressed by
|
||||
// word order and prepositions, not noun endings. Number is marked by suffix:
|
||||
//
|
||||
// Singular: base form (no suffix)
|
||||
// Dual: masc + wy / fem + ty (wy and ty in ASCII transliteration)
|
||||
// Plural: masc + w / fem + wt
|
||||
//
|
||||
// Many common nouns have suppletive or irregular plurals (recorded in the
|
||||
// vocabulary layer). This function implements the productive regular pattern.
|
||||
//
|
||||
// gram_case: accepted for API symmetry but has no effect (Egyptian is caseless).
|
||||
|
||||
fn egy_decline(noun: String, gram_case: String, number: String) -> String {
|
||||
if str_eq(number, "singular") { return noun }
|
||||
if str_eq(number, "dual") {
|
||||
// Feminine dual: if noun ends in t (feminine marker), replace with ty
|
||||
if egy_str_ends(noun, "t") {
|
||||
let stem: String = egy_drop(noun, 1)
|
||||
return stem + "ty"
|
||||
}
|
||||
return noun + "wy"
|
||||
}
|
||||
// Plural
|
||||
if egy_str_ends(noun, "t") {
|
||||
// Feminine noun: add wt
|
||||
return noun + "wt"
|
||||
}
|
||||
// Masculine noun: add w
|
||||
return noun + "w"
|
||||
}
|
||||
|
||||
// ── Feminine derivation ─────────────────────────────────────────────────────────
|
||||
//
|
||||
// egy_fem: derive the feminine form of a noun or adjective by appending -t.
|
||||
//
|
||||
// In Middle Egyptian, the feminine gender marker is the suffix -t (written with
|
||||
// the bread-loaf hieroglyph, Gardiner X1). If the base already ends in -t the
|
||||
// form is returned unchanged to avoid double-suffixing.
|
||||
|
||||
fn egy_fem(noun: String) -> String {
|
||||
if egy_str_ends(noun, "t") { return noun }
|
||||
return noun + "t"
|
||||
}
|
||||
|
||||
// ── Noun phrase assembly ────────────────────────────────────────────────────────
|
||||
//
|
||||
// egy_noun_phrase: return the surface form of a noun phrase.
|
||||
//
|
||||
// noun: base noun (ASCII transliteration)
|
||||
// gram_case: passed for API symmetry; has no effect (Egyptian is caseless)
|
||||
// number: "singular" | "dual" | "plural"
|
||||
// definite: "true" | "false" — Middle Egyptian has no article; parameter accepted
|
||||
// for API symmetry. Late Egyptian pꜣ/tꜣ/nꜣ articles are not implemented
|
||||
// here (they would require knowing the gender of each noun).
|
||||
//
|
||||
// Returns the noun in its correct number form.
|
||||
|
||||
fn egy_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String {
|
||||
return egy_decline(noun, gram_case, number)
|
||||
}
|
||||
|
||||
// ── Canonical verb mapping ──────────────────────────────────────────────────────
|
||||
//
|
||||
// egy_map_canonical: map cross-lingual English canonical verb labels to their
|
||||
// Middle Egyptian equivalents before dispatching to egy_conjugate.
|
||||
|
||||
fn egy_map_canonical(verb: String) -> String {
|
||||
if str_eq(verb, "be") { return "wnn" }
|
||||
if str_eq(verb, "give") { return "rdi" }
|
||||
if str_eq(verb, "see") { return "mAA" }
|
||||
if str_eq(verb, "say") { return "Dd" }
|
||||
if str_eq(verb, "go") { return "Sm" }
|
||||
if str_eq(verb, "do") { return "iri" }
|
||||
if str_eq(verb, "make") { return "iri" }
|
||||
if str_eq(verb, "hear") { return "sdm" }
|
||||
// Unknown: return as-is; egy_conjugate will apply the regular pattern
|
||||
return verb
|
||||
}
|
||||
Reference in New Issue
Block a user