Laenkea

Module:rad-IPA: Difference between revisions

Module Discussion

Module:rad-IPA (view source)

Revision as of 12:03, 21 July 2024

12,072 bytes added ,  21 July
m
Beautified
m (Combined stress conditions)
m (Beautified)
Line 1: Line 1:
local export = {}
local export = {}
local getArgs = require('Module:Arguments').getArgs
local getArgs = require("Module:Arguments").getArgs


-- DATA --
-- DATA --


local data = {
local data = {
["a"] = {
    ["a"] = {
["i"] = "ai",
        ["i"] = "ai",
["o"] = {
        ["o"] = {
["i"] = "ɔi",
            ["i"] = "ɔi",
[false] = "ɔː",
            [false] = "ɔː"
},
        },
["ô"] = "ɔa",
        ["ô"] = "ɔa",
["u"] = "au",
        ["u"] = "au",
[false] = "a",
        [false] = "a"
},
    },
["á"] = "aː",
    ["á"] = "aː",
["ả"] = "aːː",
    ["ả"] = "aːː",
["â"] = {
    ["â"] = {
["i"] = "ɤi",
        ["i"] = "ɤi",
[false] = "ɤ",
        [false] = "ɤ"
},
    },
["b"] = "b",
    ["b"] = "b",
["c"] = "ts",
    ["c"] = "ts",
["d"] = {
    ["d"] = {
["x"] = "dʒ",
        ["x"] = "dʒ",
["z"] = "dz",
        ["z"] = "dz",
[false] = "d",
        [false] = "d"
},
    },
["ð"] = "ð",
    ["ð"] = "ð",
["e"] = {
    ["e"] = {
["a"] = "æː",
        ["a"] = "æː",
["i"] = "ei",
        ["i"] = "ei",
[false] = "ɛ",
        [false] = "ɛ"
},
    },
["é"] = "eː",
    ["é"] = "eː",
["f"] = "f",
    ["f"] = "f",
["g"] = "ɡ",
    ["g"] = "ɡ",
["h"] = "h",
    ["h"] = "h",
["ħ"] = "ɣ",
    ["ħ"] = "ɣ",
["i"] = {
    ["i"] = {
["e"] = {
        ["e"] = {
["a"] = "ia",
            ["a"] = "ia",
["j"] = "iej",
            ["j"] = "iej",
[false] = "ie",
            [false] = "ie"
},
        },
[false] = "i",
        [false] = "i"
},
    },
["í"] = "iː",
    ["í"] = "iː",
["ỉ"] = {
    ["ỉ"] = {
["e"] = "iːe",
        ["e"] = "iːe",
[false] = "iːː",
        [false] = "iːː"
},
    },
["j"] = "j",
    ["j"] = "j",
["ĵ"] = "ĵ",
    ["ĵ"] = "ĵ",
["k"] = "k",
    ["k"] = "k",
["ķ"] = "tʃ",
    ["ķ"] = "tʃ",
["l"] = "l",
    ["l"] = "l",
["m"] = "m",
    ["m"] = "m",
["n"] = "n",
    ["n"] = "n",
["ņ"] = "ŋ",
    ["ņ"] = "ŋ",
["o"] = {
    ["o"] = {
["a"] = "ɔa",
        ["a"] = "ɔa",
[false] = "ɔ",
        [false] = "ɔ"
},
    },
["ô"] = "ɔ",
    ["ô"] = "ɔ",
["ó"] = "oː",
    ["ó"] = "oː",
["ø"] = {
    ["ø"] = {
["a"] = "œa",
        ["a"] = "œa",
["i"] = "ei",
        ["i"] = "ei",
[false] = "œ",
        [false] = "œ"
},
    },
["p"] = "p",
    ["p"] = "p",
["q"] = "k",
    ["q"] = "k",
["r"] = "r",
    ["r"] = "r",
["s"] = "s",
    ["s"] = "s",
["ș"] = "ʃ",
    ["ș"] = "ʃ",
["t"] = "t",
    ["t"] = "t",
["u"] = {
    ["u"] = {
["i"] = "ɤi",
        ["i"] = "ɤi",
["o"] = {
        ["o"] = {
["a"] = "ua",
            ["a"] = "ua",
["j"] = "uoj",
            ["j"] = "uoj",
[false] = "uo",
            [false] = "uo"
},
        },
[false] = "u",
        [false] = "u"
},
    },
["ù"] = "ù",
    ["ù"] = "ù",
["û"] = "ɤ",
    ["û"] = "ɤ",
["ú"] = "uː",
    ["ú"] = "uː",
["ủ"] = {
    ["ủ"] = {
["o"] = "uːo",
        ["o"] = "uːo",
[false] = "uːː",
        [false] = "uːː"
},
    },
["ū"] = "ū",
    ["ū"] = "ū",
["v"] = "v",
    ["v"] = "v",
["w"] = "w",
    ["w"] = "w",
["x"] = "ʒ",
    ["x"] = "ʒ",
["y"] = {
    ["y"] = {
["e"] = {
        ["e"] = {
["a"] = "ia",
            ["a"] = "ia",
["j"] = "yej",
            ["j"] = "yej",
[false] = "ie",
            [false] = "ie"
},
        },
[false] = "i",
        [false] = "i"
},
    },
["ỳ"] = "y",
    ["ỳ"] = "y",
["z"] = "z",
    ["z"] = "z",
["þ"] = "θ",
    ["þ"] = "θ",
["·"] = "·",
    ["·"] = "·",
["-"] = "-",
    ["-"] = "-",
[" "] = " ",
    [" "] = " ",
["."] = "|",
    ["."] = "|",
["'"] = "'",
    ["'"] = "'",
["‿"] = "‿",
    ["‿"] = "‿"
}
}
data["à"] = data["a"]
data["à"] = data["a"]
Line 131: Line 131:


local irregular = {
local irregular = {
["eurú"] = "ørú",
    ["eurú"] = "ørú",
["eurov"] = "ørov",
    ["eurov"] = "ørov",
["euruv"] = "øruv",
    ["euruv"] = "øruv",
["heņre"] = "heņgre",
    ["heņre"] = "heņgre",
["nrao"] = "drao",
    ["nrao"] = "drao",
["nron"] = "dron",
    ["nron"] = "dron",
["ryņl"] = "ryņgl",
    ["ryņl"] = "ryņgl",
["zeus"] = "zøs",
    ["zeus"] = "zøs",
["zeud"] = "zød",
    ["zeud"] = "zød"
}
}


local valid_phone = {
local valid_phone = {
["a"] = true, ["aː"] = true, ["aːː"] = true, ["æː"] = true, ["ai"] = true,
    ["a"] = true,
["au"] = true, ["b"] = true, ["ç"] = true, ["d"] = true, ["ð"] = true,
    ["aː"] = true,
["dz"] = true, ["dʒ"] = true, ["eː"] = true, ["ei"] = true, ["ɛ"] = true,
    ["aːː"] = true,
["ɤ"] = true, ["ɤi"] = true, ["f"] = true, ["ɡ"] = true, ["ɣ"] = true,
    ["æː"] = true,
["h"] = true, ["i"] = true, ["iː"] = true, ["iːː"] = true, ["iːe"] = true,
    ["ai"] = true,
["ia"] = true, ["ie"] = true, ["j"] = true, ["k"] = true, ["l"] = true,
    ["au"] = true,
["m"] = true, ["n"] = true, ["ŋ"] = true, ["oː"] = true, ["œ"] = true,
    ["b"] = true,
["œa"] = true, ["øi"] = true, ["ɔ"] = true, ["ɔː"] = true, ["ɔa"] = true,
    ["ç"] = true,
["ɔi"] = true, ["p"] = true, ["r"] = true, ["s"] = true, ["ʃ"] = true,
    ["d"] = true,
["t"] = true, ["ts"] = true, ["tʃ"] = true, ["u"] = true, ["uː"] = true,
    ["ð"] = true,
["uːː"] = true, ["uːo"] = true, ["ua"] = true, ["uo"] = true, ["v"] = true,
    ["dz"] = true,
["w"] = true, ["y"] = true, ["z"] = true, ["ʒ"] = true, ["θ"] = true,  
    ["dʒ"] = true,
    ["eː"] = true,
-- allophones --
    ["ei"] = true,
    ["ɛ"] = true,
["x"] = true, ["ʝ"] = true,
    ["ɤ"] = true,
    ["ɤi"] = true,
    ["f"] = true,
    ["ɡ"] = true,
    ["ɣ"] = true,
    ["h"] = true,
    ["i"] = true,
    ["iː"] = true,
    ["iːː"] = true,
    ["iːe"] = true,
    ["ia"] = true,
    ["ie"] = true,
    ["j"] = true,
    ["k"] = true,
    ["l"] = true,
    ["m"] = true,
    ["n"] = true,
    ["ŋ"] = true,
    ["oː"] = true,
    ["œ"] = true,
    ["œa"] = true,
    ["øi"] = true,
    ["ɔ"] = true,
    ["ɔː"] = true,
    ["ɔa"] = true,
    ["ɔi"] = true,
    ["p"] = true,
    ["r"] = true,
    ["s"] = true,
    ["ʃ"] = true,
    ["t"] = true,
    ["ts"] = true,
    ["tʃ"] = true,
    ["u"] = true,
    ["uː"] = true,
    ["uːː"] = true,
    ["uːo"] = true,
    ["ua"] = true,
    ["uo"] = true,
    ["v"] = true,
    ["w"] = true,
    ["y"] = true,
    ["z"] = true,
    ["ʒ"] = true,
    ["θ"] = true,
    -- allophones --
 
    ["x"] = true,
    ["ʝ"] = true
}
}
local valid_phone_temp = {"iːj", "uːj", "yːj", "ù", "ū", "ĵ"}
local valid_phone_temp = {"iːj", "uːj", "yːj", "ù", "ū", "ĵ"}
 
-- CONSONANT GROUPS --
-- CONSONANT GROUPS --


local consonant = {
local consonant = {
["b"] = true, ["ç"] = true, ["d"] = true, ["ð"] = true, ["dz"] = true,
    ["b"] = true,
["dʒ"] = true, ["f"] = true, ["ɡ"] = true, ["ɣ"] = true, ["h"] = true,
    ["ç"] = true,
["j"] = true, ["k"] = true, ["l"] = true, ["m"] = true, ["n"] = true,
    ["d"] = true,
["ŋ"] = true, ["p"] = true, ["r"] = true, ["s"] = true, ["ʃ"] = true,
    ["ð"] = true,
["t"] = true, ["ts"] = true, ["tʃ"] = true, ["v"] = true, ["w"] = true,
    ["dz"] = true,
["z"] = true, ["ʒ"] = true, ["θ"] = true,  
    ["dʒ"] = true,
    ["f"] = true,
-- allophones --
    ["ɡ"] = true,
    ["ɣ"] = true,
["x"] = true, ["ʝ"] = true, ["ʋ"] = true, ["ɲ"] = true, ["r̥"] = true,
    ["h"] = true,
    ["j"] = true,
    ["k"] = true,
    ["l"] = true,
    ["m"] = true,
    ["n"] = true,
    ["ŋ"] = true,
    ["p"] = true,
    ["r"] = true,
    ["s"] = true,
    ["ʃ"] = true,
    ["t"] = true,
    ["ts"] = true,
    ["tʃ"] = true,
    ["v"] = true,
    ["w"] = true,
    ["z"] = true,
    ["ʒ"] = true,
    ["θ"] = true,
    -- allophones --
 
    ["x"] = true,
    ["ʝ"] = true,
    ["ʋ"] = true,
    ["ɲ"] = true,
    ["r̥"] = true
}
}
local consonant_temp = {"ĵ"}
local consonant_temp = {"ĵ"}
 
local velar = {
local velar = {
["k"] = true, ["ɡ"] = true, ["ɣ"] = true, ["ŋ"] = true,
    ["k"] = true,
    ["ɡ"] = true,
-- allophones --
    ["ɣ"] = true,
    ["ŋ"] = true,
["x"] = true,
    -- allophones --
 
    ["x"] = true
}
}
 
local obstruent = {
local obstruent = {
["b"] = true, ["ç"] = true, ["d"] = true, ["ð"] = true, ["dz"] = true,
    ["b"] = true,
["dʒ"] = true, ["f"] = true, ["ɡ"] = true, ["ɣ"] = true, ["h"] = true,
    ["ç"] = true,
["k"] = true, ["p"] = true, ["s"] = true, ["ʃ"] = true,
    ["d"] = true,
["t"] = true, ["ts"] = true, ["tʃ"] = true, ["v"] = true,
    ["ð"] = true,
["z"] = true, ["ʒ"] = true, ["θ"] = true,  
    ["dz"] = true,
    ["dʒ"] = true,
-- allophones --
    ["f"] = true,
    ["ɡ"] = true,
["x"] = true, ["ʋ"] = true,
    ["ɣ"] = true,
    ["h"] = true,
    ["k"] = true,
    ["p"] = true,
    ["s"] = true,
    ["ʃ"] = true,
    ["t"] = true,
    ["ts"] = true,
    ["tʃ"] = true,
    ["v"] = true,
    ["z"] = true,
    ["ʒ"] = true,
    ["θ"] = true,
    -- allophones --
 
    ["x"] = true,
    ["ʋ"] = true
}
 
local obstruent_voiced = {
    ["b"] = true,
    ["d"] = true,
    ["ð"] = true,
    ["dz"] = true,
    ["dʒ"] = true,
    ["ɡ"] = true,
    ["ɣ"] = true,
    ["v"] = true,
    ["z"] = true,
    ["ʒ"] = true
}
 
local obstruent_devoice = {
    ["b"] = "p",
    ["ç"] = "ç",
    ["d"] = "t",
    ["ð"] = "θ",
    ["dz"] = "ts",
    ["dʒ"] = "tʃ",
    ["f"] = "f",
    ["ɡ"] = "k",
    ["ɣ"] = "h",
    ["h"] = "h",
    ["k"] = "k",
    ["p"] = "p",
    ["s"] = "s",
    ["ʃ"] = "ʃ",
    ["t"] = "t",
    ["ts"] = "ts",
    ["tʃ"] = "tʃ",
    ["v"] = "f",
    ["z"] = "s",
    ["ʒ"] = "ʃ",
    ["θ"] = "θ",
    -- allophones --
 
    ["x"] = "x"
}
 
local obstruent_voice = {
    ["b"] = "b",
    ["ç"] = "j",
    ["d"] = "d",
    ["ð"] = "ð",
    ["dz"] = "dz",
    ["dʒ"] = "dʒ",
    ["f"] = "v",
    ["ɡ"] = "ɡ",
    ["ɣ"] = "ɣ",
    ["h"] = "h",
    ["k"] = "ɡ",
    ["p"] = "b",
    ["s"] = "z",
    ["ʃ"] = "ʒ",
    ["t"] = "d",
    ["ts"] = "dz",
    ["tʃ"] = "dʒ",
    ["v"] = "v",
    ["z"] = "z",
    ["ʒ"] = "ʒ",
    ["θ"] = "ð",
    -- allophones --
 
    ["x"] = "ɣ"
}
}


local obstruent_voiced = {
["b"] = true, ["d"] = true, ["ð"] = true, ["dz"] = true,
["dʒ"] = true, ["ɡ"] = true, ["ɣ"] = true,
["v"] = true,
["z"] = true, ["ʒ"] = true,
}
local obstruent_devoice = {
["b"] = "p", ["ç"] = "ç", ["d"] = "t", ["ð"] = "θ", ["dz"] = "ts",
["dʒ"] = "tʃ", ["f"] = "f", ["ɡ"] = "k", ["ɣ"] = "h", ["h"] = "h",
["k"] = "k", ["p"] = "p", ["s"] = "s", ["ʃ"] = "ʃ",
["t"] = "t", ["ts"] = "ts", ["tʃ"] = "tʃ", ["v"] = "f",
["z"] = "s", ["ʒ"] = "ʃ", ["θ"] = "θ",
-- allophones --
["x"] = "x",
}
local obstruent_voice = {
["b"] = "b", ["ç"] = "j", ["d"] = "d", ["ð"] = "ð", ["dz"] = "dz",
["dʒ"] = "dʒ", ["f"] = "v", ["ɡ"] = "ɡ", ["ɣ"] = "ɣ", ["h"] = "h",
["k"] = "ɡ", ["p"] = "b", ["s"] = "z", ["ʃ"] = "ʒ",
["t"] = "d", ["ts"] = "dz", ["tʃ"] = "dʒ", ["v"] = "v",
["z"] = "z", ["ʒ"] = "ʒ", ["θ"] = "ð",
-- allophones --
["x"] = "ɣ",
}
local affricate = {
local affricate = {
["dz"] = true, ["dʒ"] = true ,
    ["dz"] = true,
["ts"] = true, ["tʃ"] = true,
    ["dʒ"] = true,
    ["ts"] = true,
    ["tʃ"] = true
}
}
 
local sibilant = {
local sibilant = {
["dz"] = true, ["dʒ"] = true ,
    ["dz"] = true,
["s"] = true, ["ʃ"] = true,
    ["dʒ"] = true,
["ts"] = true, ["tʃ"] = true,
    ["s"] = true,
["z"] = true, ["ʒ"] = true,
    ["ʃ"] = true,
    ["ts"] = true,
    ["tʃ"] = true,
    ["z"] = true,
    ["ʒ"] = true
}
 
local sibilant_alv = {
    ["dz"] = true,
    ["s"] = true,
    ["ts"] = true,
    ["z"] = true
}
}


local sibilant_alv = {
local sibilant_post = {
["dz"] = true,
    ["dʒ"] = true,
["s"] = true,
    ["ʃ"] = true,
["ts"] = true,
    ["tʃ"] = true,
["z"] = true,
    ["ʒ"] = true
}
}


local sibilant_post = {
local sibilant_alv_to_post = {
["dʒ"] = true,
    ["dz"] = "dʒ",
["ʃ"] = true,
    ["s"] = "ʃ",
["tʃ"] = true,
    ["ts"] = "tʃ",
["ʒ"] = true,
    ["z"] = "ʒ"
}
}
local sibilant_alv_to_post = {
["dz"] = "dʒ",
["s"] = "ʃ",
["ts"] = "tʃ",
["z"] = "ʒ",
}


local nasal = {
local nasal = {
["m"] = true, ["n"] = true, ["ŋ"] = true,
    ["m"] = true,
    ["n"] = true,
["ɲ"] = true,
    ["ŋ"] = true,
    ["ɲ"] = true
}
}
 
local glide = {
local glide = {
["j"] = true, ["w"] = true,
    ["j"] = true,
    ["w"] = true
}
}
local glide_temp = {"ĵ"}
local glide_temp = {"ĵ"}
 
local iotate = {
local iotate = {
["d"] = "dʒ", ["dz"] = "dʒ",
    ["d"] = "dʒ",
["ɡ"] = "j", ["ɣ"] = "j",
    ["dz"] = "dʒ",
["h"] = "ç",
    ["ɡ"] = "j",
["k"] = "tʃ",
    ["ɣ"] = "j",
["l"] = "j",
    ["h"] = "ç",
["s"] = "ʃ",
    ["k"] = "tʃ",
["t"] = "tʃ", ["ts"] = "tʃ",
    ["l"] = "j",
["z"] = "ʒ",
    ["s"] = "ʃ",
    ["t"] = "tʃ",
    ["ts"] = "tʃ",
    ["z"] = "ʒ"
}
}


local Cv_fixed = { -- <Cv> combinations that uniformly pronounced without /v/ --
local Cv_fixed = {
["b"] = true,
    -- <Cv> combinations that uniformly pronounced without /v/ --
["f"] = true,
    ["b"] = true,
["p"] = true,
    ["f"] = true,
    ["p"] = true
}
}


local Cv_split = { -- <Cv> combinations that are only pronounced with /v/ post-vocalically --
local Cv_split = {
["m"] = true, ["n"] = true,
    -- <Cv> combinations that are only pronounced with /v/ post-vocalically --
    ["m"] = true,
    ["n"] = true
}
}


local Cr = { -- consonants that can precede /r/ in a medial onset --
local Cr = {
["p"] = true, ["k"] = true, ["b"] = true, ["ɡ"] = true,  
    -- consonants that can precede /r/ in a medial onset --
    ["p"] = true,
["ç"] = true, ["ð"] = true,
    ["k"] = true,
["f"] = true, ["ɣ"] = true, ["h"] = true,
    ["b"] = true,
["v"] = true,
    ["ɡ"] = true,
["θ"] = true,  
    ["ç"] = true,
    ["ð"] = true,
["t"] = true, ["d"] = true,
    ["f"] = true,
    ["ɣ"] = true,
-- allophones --
    ["h"] = true,
    ["v"] = true,
["x"] = true, ["ʋ"] = true,
    ["θ"] = true,
    ["t"] = true,
    ["d"] = true,
    -- allophones --
 
    ["x"] = true,
    ["ʋ"] = true
}
}


local Cl = { -- consonants that can precede /l/ in a medial onset --
local Cl = {
["p"] = true, ["k"] = true, ["b"] = true, ["ɡ"] = true,  
    -- consonants that can precede /l/ in a medial onset --
    ["p"] = true,
["ç"] = true, ["ð"] = true,
    ["k"] = true,
["f"] = true, ["ɣ"] = true, ["h"] = true,
    ["b"] = true,
["v"] = true,
    ["ɡ"] = true,
["θ"] = true,  
    ["ç"] = true,
    ["ð"] = true,
["s"] = true, ["ʃ"] = true, ["z"] = true, ["ʒ"] = true,  
    ["f"] = true,
    ["ɣ"] = true,
-- allophones --
    ["h"] = true,
    ["v"] = true,
["x"] = true, ["ʋ"] = true,
    ["θ"] = true,
    ["s"] = true,
    ["ʃ"] = true,
    ["z"] = true,
    ["ʒ"] = true,
    -- allophones --
 
    ["x"] = true,
    ["ʋ"] = true
}
}


local Cv = { -- consonants that can precede /v/ in a medial onset --
local Cv = {
["ç"] = true, ["d"] = true, ["ð"] = true, ["dz"] = true,
    -- consonants that can precede /v/ in a medial onset --
["dʒ"] = true, ["ɡ"] = true, ["ɣ"] = true, ["h"] = true,
    ["ç"] = true,
["k"] = true, ["l"] = true, ["r"] = true, ["s"] = true, ["ʃ"] = true,
    ["d"] = true,
["t"] = true, ["ts"] = true, ["tʃ"] = true,
    ["ð"] = true,
["z"] = true, ["ʒ"] = true, ["θ"] = true,
    ["dz"] = true,
    ["dʒ"] = true,
-- allophones --
    ["ɡ"] = true,
    ["ɣ"] = true,
["x"] = true, ["ʝ"] = true,
    ["h"] = true,
    ["k"] = true,
    ["l"] = true,
    ["r"] = true,
    ["s"] = true,
    ["ʃ"] = true,
    ["t"] = true,
    ["ts"] = true,
    ["tʃ"] = true,
    ["z"] = true,
    ["ʒ"] = true,
    ["θ"] = true,
    -- allophones --
 
    ["x"] = true,
    ["ʝ"] = true
}
}


local continuant = { -- consonants that can precede nasals in a medial onset -- (non-glide continuants)
local continuant = {
["ç"] = true, ["ð"] = true,
    -- consonants that can precede nasals in a medial onset -- (non-glide continuants)
["f"] = true, ["ɣ"] = true, ["h"] = true,
    ["ç"] = true,
["l"] = true, ["r"] = true, ["s"] = true, ["ʃ"] = true,
    ["ð"] = true,
["v"] = true,
    ["f"] = true,
["z"] = true, ["ʒ"] = true, ["θ"] = true,  
    ["ɣ"] = true,
    ["h"] = true,
-- allophones --
    ["l"] = true,
    ["r"] = true,
["x"] = true, ["ʋ"] = true,
    ["s"] = true,
    ["ʃ"] = true,
    ["v"] = true,
    ["z"] = true,
    ["ʒ"] = true,
    ["θ"] = true,
    -- allophones --
 
    ["x"] = true,
    ["ʋ"] = true
}
}
local CN = continuant
local CN = continuant
 
local fricative = {
    -- excludes [h]
    ["ç"] = true,
    ["ð"] = true,
    ["f"] = true,
    ["ɣ"] = true,
    ["l"] = true,
    ["r"] = true,
    ["s"] = true,
    ["ʃ"] = true,
    ["v"] = true,
    ["z"] = true,
    ["ʒ"] = true,
    ["θ"] = true,
    -- allophones --


local fricative = {  -- excludes [h]
    ["x"] = true,
["ç"] = true, ["ð"] = true,
    ["ʋ"] = true
["f"] = true, ["ɣ"] = true,
["l"] = true, ["r"] = true, ["s"] = true, ["ʃ"] = true,
["v"] = true,
["z"] = true, ["ʒ"] = true, ["θ"] = true,
-- allophones --
["x"] = true, ["ʋ"] = true,
}
}


Line 364: Line 551:


local vowel = {
local vowel = {
["a"] = true, ["aː"] = true, ["aːː"] = true, ["æː"] = true, ["ai"] = true, ["au"] = true,
    ["a"] = true,
["eː"] = true, ["ei"] = true, ["ɛ"] = true, ["ɤ"] = true, ["ɤi"] = true, ["i"] = true,
    ["aː"] = true,
["iː"] = true, ["iːː"] = true, ["iːe"] = true, ["ia"] = true, ["ie"] = true, ["oː"] = true,
    ["aːː"] = true,
["œ"] = true, ["œa"] = true, ["øi"] = true, ["ɔ"] = true, ["ɔː"] = true, ["ɔa"] = true,
    ["æː"] = true,
["ɔi"] = true, ["u"] = true, ["uː"] = true, ["uːː"] = true, ["uːo"] = true, ["ua"] = true,
    ["ai"] = true,
["uo"] = true, ["y"] = true,
    ["au"] = true,
    ["eː"] = true,
    ["ei"] = true,
    ["ɛ"] = true,
    ["ɤ"] = true,
    ["ɤi"] = true,
    ["i"] = true,
    ["iː"] = true,
    ["iːː"] = true,
    ["iːe"] = true,
    ["ia"] = true,
    ["ie"] = true,
    ["oː"] = true,
    ["œ"] = true,
    ["œa"] = true,
    ["øi"] = true,
    ["ɔ"] = true,
    ["ɔː"] = true,
    ["ɔa"] = true,
    ["ɔi"] = true,
    ["u"] = true,
    ["uː"] = true,
    ["uːː"] = true,
    ["uːo"] = true,
    ["ua"] = true,
    ["uo"] = true,
    ["y"] = true
}
}
local vowel_temp = {"iːj", "uːj", "yːj", "ù", "ū"}
local vowel_temp = {"iːj", "uːj", "yːj", "ù", "ū"}
 
local marked_hiatus = {
local marked_hiatus = {
["a"] = true, ["ai"] = true, ["au"] = true,
    ["a"] = true,
["ei"] = true, ["ɛ"] = true, ["ɤ"] = true, ["ɤi"] = true, ["i"] = true,
    ["ai"] = true,
["iːe"] = true, ["ia"] = true, ["ie"] = true, ["oː"] = true,
    ["au"] = true,
["œ"] = true, ["œa"] = true, ["øi"] = true, ["ɔ"] = true, ["ɔa"] = true,
    ["ei"] = true,
["ɔi"] = true, ["u"] = true, ["uːo"] = true, ["ua"] = true,
    ["ɛ"] = true,
["uo"] = true, ["y"] = true,
    ["ɤ"] = true,
    ["ɤi"] = true,
    ["i"] = true,
    ["iːe"] = true,
    ["ia"] = true,
    ["ie"] = true,
    ["oː"] = true,
    ["œ"] = true,
    ["œa"] = true,
    ["øi"] = true,
    ["ɔ"] = true,
    ["ɔa"] = true,
    ["ɔi"] = true,
    ["u"] = true,
    ["uːo"] = true,
    ["ua"] = true,
    ["uo"] = true,
    ["y"] = true
}
}
 
local long = {
local long = {
["aː"] = true, ["aːː"] = true, ["æː"] = true, ["ai"] = true, ["au"] = true,
    ["aː"] = true,
["eː"] = true, ["ei"] = true, ["ɤi"] = true,  
    ["aːː"] = true,
["iː"] = true, ["iːː"] = true, ["iːe"] = true, ["ia"] = true, ["ie"] = true, ["oː"] = true,
    ["æː"] = true,
["œa"] = true, ["øi"] = true, ["ɔː"] = true, ["ɔa"] = true,
    ["ai"] = true,
["ɔi"] = true, ["uː"] = true, ["uːː"] = true, ["uːo"] = true, ["ua"] = true,
    ["au"] = true,
["uo"] = true,
    ["eː"] = true,
    ["ei"] = true,
    ["ɤi"] = true,
    ["iː"] = true,
    ["iːː"] = true,
    ["iːe"] = true,
    ["ia"] = true,
    ["ie"] = true,
    ["oː"] = true,
    ["œa"] = true,
    ["øi"] = true,
    ["ɔː"] = true,
    ["ɔa"] = true,
    ["ɔi"] = true,
    ["uː"] = true,
    ["uːː"] = true,
    ["uːo"] = true,
    ["ua"] = true,
    ["uo"] = true
}
}


local weak = {
local weak = {
["ɤ"] = true, ["i"] = true,
    ["ɤ"] = true,
    ["i"] = true
}
}


-- allophonic only --
-- allophonic only --
local nasalise = {
local nasalise = {
["a"] = "ãˑ", ["aː"] = "ãːˑ", ["aːː"] = "ãːːˑ", ["æː"] = "æ̃ːˑ", ["ai"] = "ãˑĩ", ["au"] = "ãˑũ",
    ["a"] = "ãˑ",
["eː"] = "ẽːˑ", ["ei"] = "ẽˑĩ", ["ɛ"] = "ɛ̃ˑ", ["ɤ"] = "ɤ̃ˑ", ["ɤi"] = "ɤ̃ˑĩ", ["i"] = "ĩˑ",
    ["aː"] = "ãːˑ",
["iː"] = "ĩːˑ", ["iːː"] = "ĩːːˑ", ["iːe"] = "ĩːˑẽ", ["ia"] = "ĩˑã", ["ie"] = "ĩˑẽ", ["oː"] = "õːˑ",
    ["aːː"] = "ãːːˑ",
["œ"] = "œ̃ˑ", ["œa"] = "œ̃ˑã", ["øi"] = "ø̃ˑĩ", ["ɔ"] = "ɔ̃ˑ", ["ɔː"] = "ɔ̃ːˑ", ["ɔa"] = "ɔ̃ˑã",
    ["æː"] = "æ̃ːˑ",
["ɔi"] = "ɔ̃ˑĩ", ["u"] = "ũˑ", ["uː"] = "ũːˑ", ["uːː"] = "ũːːˑ", ["uːo"] = "ũːˑõ", ["ua"] = "ũˑã",
    ["ai"] = "ãˑĩ",
["uo"] = "ũˑõ", ["y"] = "ỹˑ",
    ["au"] = "ãˑũ",
    ["eː"] = "ẽːˑ",
["ɑ"] = "ɑ̃ˑ",
    ["ei"] = "ẽˑĩ",
["ä"] = "ä̃ˑ",
    ["ɛ"] = "ɛ̃ˑ",
["äi"] = "ä̃ˑĩ",
    ["ɤ"] = "ɤ̃ˑ",
["äu"] = "ä̃ˑũ",
    ["ɤi"] = "ɤ̃ˑĩ",
["iɐ"] = "ĩˑɐ̃",
    ["i"] = "ĩˑ",
["uɐ"] = "ũˑɐ̃",
    ["iː"] = "ĩːˑ",
    ["iːː"] = "ĩːːˑ",
    ["iːe"] = "ĩːˑẽ",
    ["ia"] = "ĩˑã",
    ["ie"] = "ĩˑẽ",
    ["oː"] = "õːˑ",
    ["œ"] = "œ̃ˑ",
    ["œa"] = "œ̃ˑã",
    ["øi"] = "ø̃ˑĩ",
    ["ɔ"] = "ɔ̃ˑ",
    ["ɔː"] = "ɔ̃ːˑ",
    ["ɔa"] = "ɔ̃ˑã",
    ["ɔi"] = "ɔ̃ˑĩ",
    ["u"] = "ũˑ",
    ["uː"] = "ũːˑ",
    ["uːː"] = "ũːːˑ",
    ["uːo"] = "ũːˑõ",
    ["ua"] = "ũˑã",
    ["uo"] = "ũˑõ",
    ["y"] = "ỹˑ",
    ["ɑ"] = "ɑ̃ˑ",
    ["ä"] = "ä̃ˑ",
    ["äi"] = "ä̃ˑĩ",
    ["äu"] = "ä̃ˑũ",
    ["iɐ"] = "ĩˑɐ̃",
    ["uɐ"] = "ũˑɐ̃"
}
}
 
-- MISC --
-- MISC --


local boundary = {
local boundary = {
[" "] = true, ["|"] = true, ["·"] = true, ["‿"] = true,
    [" "] = true,
    ["|"] = true,
    ["·"] = true,
    ["‿"] = true
}
}


function process_temp()
function process_temp()
for _, temp in ipairs(valid_phone_temp) do
    for _, temp in ipairs(valid_phone_temp) do
valid_phone[temp] = true
        valid_phone[temp] = true
end
    end
for _, temp in ipairs(vowel_temp) do
    for _, temp in ipairs(vowel_temp) do
vowel[temp] = true
        vowel[temp] = true
end
    end
for _, temp in ipairs(consonant_temp) do
    for _, temp in ipairs(consonant_temp) do
consonant[temp] = true
        consonant[temp] = true
end
    end
for _, temp in ipairs(glide_temp) do
    for _, temp in ipairs(glide_temp) do
glide[temp] = true
        glide[temp] = true
end
    end
end
end


Line 438: Line 715:


function generate_IPA(word)
function generate_IPA(word)
local s = mw.ustring.lower(word)
    local s = mw.ustring.lower(word)
 
-- Replace irregulars --
    -- Replace irregulars --
 
for toReplace, ReplaceKey in pairs(irregular) do
    for toReplace, ReplaceKey in pairs(irregular) do
if mw.ustring.find(s, toReplace) then
        if mw.ustring.find(s, toReplace) then
s = mw.ustring.gsub(s, "(" .. toReplace .. ")", ReplaceKey)
            s = mw.ustring.gsub(s, "(" .. toReplace .. ")", ReplaceKey)
-- mw.log("Irregular spelling <" .. toReplace .. "> recognised. Treating as <" .. ReplaceKey .. ">.")
        -- mw.log("Irregular spelling <" .. toReplace .. "> recognised. Treating as <" .. ReplaceKey .. ">.")
end
        end
end
    end
 
if mw.ustring.find(s, "(rredeș)") then -- deals with Rredeșa and Rrezlieþs
    if mw.ustring.find(s, "(rredeș)") then -- deals with Rredeșa and Rrezlieþs
s = mw.ustring.gsub(s, "(a rredeș)", "ar‿redeș")
        s = mw.ustring.gsub(s, "(a rredeș)", "ar‿redeș")
s = mw.ustring.gsub(s, "(u rredeș)", "ùr‿redeș")
        s = mw.ustring.gsub(s, "(u rredeș)", "ùr‿redeș")
s = mw.ustring.gsub(s, "(rredeș)", "redeș")
        s = mw.ustring.gsub(s, "(rredeș)", "redeș")
elseif mw.ustring.find(s, "(rrezl)") then
    elseif mw.ustring.find(s, "(rrezl)") then
s = mw.ustring.gsub(s, "(u rrezl)", "ùr‿rezl")
        s = mw.ustring.gsub(s, "(u rrezl)", "ùr‿rezl")
s = mw.ustring.gsub(s, "(rrezl)", "rezl")
        s = mw.ustring.gsub(s, "(rrezl)", "rezl")
end
    end
 
local s_len = mw.ustring.len(s)
    local s_len = mw.ustring.len(s)
IPA = {}
    IPA = {}
 
    local split_s = {}
    for i = 1, s_len do
        split_s[i] = mw.ustring.sub(s, i, i)
    end


local split_s = {}
    -- generate_IPA: mw.log("————— BEGINNING BASE GENERATION —————")
for i = 1, s_len do
  split_s[i] = mw.ustring.sub(s, i,i)
end
-- generate_IPA: mw.log("————— BEGINNING BASE GENERATION —————")


if s_len == 0 then
    if s_len == 0 then
error("Empty input")
        error("Empty input")
end
    end


while s_len > 0 do
    while s_len > 0 do
local getData = {}
        local getData = {}
local multiMatch = false
        local multiMatch = false
local i_iteration = -2
        local i_iteration = -2


-- generate_IPA: mw.log("=========================\nCURRENT TEST STRING: <".. mw.ustring.upper(s) .. ">")
        -- generate_IPA: mw.log("=========================\nCURRENT TEST STRING: <".. mw.ustring.upper(s) .. ">")


if s_len < 3 then
        if s_len < 3 then
i_iteration = 1 - s_len
            i_iteration = 1 - s_len
end
        end


for i = i_iteration, 0 do
        for i = i_iteration, 0 do
  -- generate_IPA: mw.log("————— <" .. split_s[s_len + i] .. "> selected. (i = " .. i .. ") —————")
            -- generate_IPA: mw.log("————— <" .. split_s[s_len + i] .. "> selected. (i = " .. i .. ") —————")
  getData = data[split_s[s_len + i]]
            getData = data[split_s[s_len + i]]
  local deadEnd = false
            local deadEnd = false
 
 
  if data[split_s[s_len + i]] == nil then
            if data[split_s[s_len + i]] == nil then
error("'" .. split_s[s_len + i] .. "' is an invalid character")
                error("'" .. split_s[s_len + i] .. "' is an invalid character")
  end
            end
 
 
  while type(getData) == "table" do
            while type(getData) == "table" do
if i == 0 then
                if i == 0 then
if getData[false] then
                    if getData[false] then
  -- generate_IPA: mw.log("Singular index recognised.")
                        -- generate_IPA: mw.log("Index acquired: " .. getData)
  getData = getData[false]
                        -- generate_IPA: mw.log("Singular index recognised.")
  -- generate_IPA: mw.log("Index acquired: " .. getData)
                        getData = getData[false]
else
                    else
  error(split_s[s_len] .. " is an invalid character")
                        error(split_s[s_len] .. " is an invalid character")
end
                    end
else
                else
  -- generate_IPA: mw.log("Tabular index recognised.")
                    -- generate_IPA: mw.log("Tabular index recognised.")
  for j = 1, 0 - i do
                    for j = 1, 0 - i do
local currentCombo = ""
                        local currentCombo = ""
-- for logs only
                        -- for logs only
if i == -2 and j == 2 then
                        if i == -2 and j == 2 then
currentCombo = split_s[s_len + i + j - 2] .. " + " .. split_s[s_len + i + j - 1] .. " + " .. split_s[s_len + i + j]
                            currentCombo =
else
                                split_s[s_len + i + j - 2] ..
currentCombo = split_s[s_len + i + j - 1] .. " + " .. split_s[s_len + i + j]
                                " + " .. split_s[s_len + i + j - 1] .. " + " .. split_s[s_len + i + j]
end
                        else
-- generate_IPA: mw.log("Testing " .. currentCombo)
                            currentCombo = split_s[s_len + i + j - 1] .. " + " .. split_s[s_len + i + j]
--
                        end
if getData[split_s[s_len + i + j]] then
                        -- generate_IPA: mw.log("Testing " .. currentCombo)
  getData = getData[split_s[s_len + i + j]]
                        --
  -- generate_IPA: mw.log("Combination recognised: " .. currentCombo .. " (j = " .. j .. ")")
                        if getData[split_s[s_len + i + j]] then
  if type(getData) == "string" then
                            getData = getData[split_s[s_len + i + j]]
                            -- generate_IPA: mw.log("Combination recognised: " .. currentCombo .. " (j = " .. j .. ")")
if j + i == 0 then
                            if type(getData) == "string" then
  -- generate_IPA: mw.log("Index acquired: " .. getData)
                                if j + i == 0 then
  multiMatch = true
                                    -- generate_IPA: mw.log("Index acquired: " .. getData)
  break
                                    multiMatch = true
else
                                    break
  -- generate_IPA: mw.log('Non-final index: dead end.')
                                else
  getData = {}
                                    -- generate_IPA: mw.log('Non-final index: dead end.')
  deadEnd = true
                                    getData = {}
  break
                                    deadEnd = true
end
                                    break
                                end
  elseif j + i == 0 and getData[false] then
                            elseif j + i == 0 and getData[false] then
getData = getData[false]
                                getData = getData[false]
-- generate_IPA: mw.log("Index acquired: " .. getData)
                                -- generate_IPA: mw.log("Index acquired: " .. getData)
multiMatch = true
                                multiMatch = true
break
                                break
  elseif j + i == 0 and not getData[false] then
                            elseif j + i == 0 and not getData[false] then
error("data[" .. table.concat(getData, "][") .. "][false] is missing." )
                                error("data[" .. table.concat(getData, "][") .. "][false] is missing.")
  else
                            else
-- generate_IPA: mw.log("Target still tabular: reiterating.")
                                -- generate_IPA: mw.log("Target still tabular: reiterating.")
  end
                            end
  else
                        else
-- generate_IPA: mw.log('Dead end.')
                            -- generate_IPA: mw.log('Dead end.')
getData = {}
                            getData = {}
deadEnd = true
                            deadEnd = true
break
                            break
end
                        end
  end
                    end
  if type(getData) == "table" then break end
                    if type(getData) == "table" then
end
                        break
  end
                    end
  if type(getData) == "string" and (i == 0 or multiMatch == true) then
                end
  -- generate_IPA: mw.log("Target acquired of length " .. 1 - i .. ", converting to [" .. getData .. "].")
            end
  table.insert(IPA, 1, getData)
            if type(getData) == "string" and (i == 0 or multiMatch == true) then
  s = mw.ustring.sub(s, 1, s_len + i - 1)
                -- generate_IPA: mw.log("Target acquired of length " .. 1 - i .. ", converting to [" .. getData .. "].")
  s_len = mw.ustring.len(s)
                table.insert(IPA, 1, getData)
  break
                s = mw.ustring.sub(s, 1, s_len + i - 1)
elseif deadEnd == false then
                s_len = mw.ustring.len(s)
-- generate_IPA: mw.log('Non-final index: dead end.')
                break
  end
            elseif deadEnd == false then
end
            -- generate_IPA: mw.log('Non-final index: dead end.')
end
            end
        end
    end


-- generate_IPA: mw.log('————— STRING EXHAUSTED —————')
    -- generate_IPA: mw.log('————— STRING EXHAUSTED —————')
-- generate_IPA: mw.log("Base generation result: [" .. table.concat(IPA,"][") .. "]")
    -- generate_IPA: mw.log("Base generation result: [" .. table.concat(IPA,"][") .. "]")
return IPA
    return IPA
end
end


function resolve_vowels(phones)
function resolve_vowels(phones)
local working_phones = phones
    local working_phones = phones
-- mw.log("————— BEGINNING VOWEL RESOLUTION —————")
    -- mw.log("————— BEGINNING VOWEL RESOLUTION —————")
 
    local i = 0
    while true do
        i = i + 1
        local p_prev = working_phones[i - 1]
        local p_current = working_phones[i]
        local p_next = working_phones[i + 1]
        local p_next2 = working_phones[i + 2]
        local p_next3 = working_phones[i + 3]
 
        if p_current == nil then
            break
        end
 
        local function update_p()
            p_prev = working_phones[i - 1]
            p_current = working_phones[i]
            p_next = working_phones[i + 1]
            p_next2 = working_phones[i + 2]
            p_next3 = working_phones[i + 3]
        end
 
        local function p_Resolve(p_new)
            working_phones[i] = p_new
            -- mw.log("[" .. p_current .. "] resolved to [" .. p_new .. "] in position ".. i .. ".")
            p_new = ""
        end
 
        local function p_Convert(p_new)
            working_phones[i] = p_new
            -- mw.log("[" .. p_current .. "] converted to [" .. p_new .. "] in position ".. i .. ".")
            p_current = p_new
            p_new = ""
        end
 
        local function p_RemoveNext()
            table.remove(working_phones, i + 1)
            update_p()
        end
 
        -- Resolution of [aù] --
        if p_prev == "a" and p_current == "ù" then
            -- mw.log("<aù> recognised in position " .. i .. ". Converting to resolvable [u].")
            p_Convert("u")
            p_current = "u"
        end
 
        -- Resolution of [u], [ù] and [ū] --
        if p_current == "u" then
            -- mw.log("[u] found in position " .. i .. ". Testing for resolution.")
            if consonant[p_next] then
                if glide[p_next2] then
                    if not vowel[p_next3] then
                        -- mw.log("ɤCj!V environment identified.")
                        p_Convert("ɤ")
                    else
                        -- mw.log("No resolution needed.")
                    end
                elseif not vowel[p_next2] then
                    -- mw.log("ɤC!V environment identified.")
                    p_Convert("ɤ")
                else
                    -- mw.log("No resolution needed.")
                end
            else
                -- mw.log("No resolution needed.")
            end
        elseif p_current == "ù" or p_current == "ū" then
            -- mw.log("Fixed [u] found in position " .. i .. ".")
            p_Convert("u")
        end
 
        -- Resolution of <Vj> to diphthongs
        if p_next == "j" and not vowel[p_next2] then
            if p_current == "a" then
                p_Resolve("ai")
                p_RemoveNext()
            elseif p_current == "ɤ" then
                p_Resolve("ɤi")
                p_RemoveNext()
            elseif p_current == "ɛ" then
                p_Resolve("ei")
                p_RemoveNext()
            elseif p_current == "ɔː" then
                p_Resolve("ɔi")
                p_RemoveNext()
            end
        end
 
        -- Resolution of <ei> and  <øi> --
        if p_current == "ei" then
            for j = 1, i do
                local check_phone = working_phones[i - j]
                if boundary[check_phone] or check_phone == nil then
                    -- mw.log("Initial [ei] found in position" .. i .. ".")
                    p_Resolve("ai")
                    break
                elseif not consonant[check_phone] then
                    break
                end
            end
        end
 
        if vowel[p_next] then
            -- Resolution of prevocalic <iej>, <uoj> and <yej> --
 
            if p_current == "iej" or p_current == "yej" or p_current == "uoj" then
                -- mw.log("Pre-vocalic <" .. p_current .. "> found in position " .. i .. ".")
                if p_current == "uoj" then
                    p_Resolve("uo")
                    table.insert(working_phones, i + 1, "j")
                    -- mw.log("[j] inserted to position " .. i + 1 .. ".")
                    update_p()
                else
                    p_Resolve("iː")
                end
            end
 
            -- Resolution of prevocalic [ie] and [uo] --
 
            if p_current == "ie" then
                p_Resolve("iː")
            elseif p_current == "uo" and p_next ~= "j" then
                p_Resolve("uː")
            end
        else
            -- Resolution of non-prevocalic <iej>, <uoj> and <yej> --
 
            for toResolve, ResolveKey in pairs({["iej"] = "ei", ["uoj"] = "ɔi", ["yej"] = "øi"}) do
                if p_current == toResolve then
                    p_Resolve(ResolveKey)
                end
            end
        end
 
        -- Resolution of [j] after [i]


local i = 0
        if p_current == "j" and (p_prev == "i" or p_prev == "iː" or p_prev == "iːː") then
while true do
            table.remove(working_phones, i)
i = i + 1
            i = i - 1
local p_prev = working_phones[i - 1]
            update_p()
local p_current = working_phones[i]
        end
local p_next = working_phones[i + 1]
    end
local p_next2 = working_phones[i + 2]
 
local p_next3 = working_phones[i + 3]
    -- Removes placeholder phones from data --
 
if p_current == nil then break end
    for _, temp in ipairs(vowel_temp) do
        valid_phone[temp] = nil
local function update_p()
        vowel[temp] = nil
p_prev = working_phones[i - 1]
    end
p_current = working_phones[i]
p_next = working_phones[i + 1]
p_next2 = working_phones[i + 2]
p_next3 = working_phones[i + 3]
end
local function p_Resolve(p_new)
working_phones[i] = p_new
-- mw.log("[" .. p_current .. "] resolved to [" .. p_new .. "] in position ".. i .. ".")
p_new = ""
end
local function p_Convert(p_new)
working_phones[i] = p_new
-- mw.log("[" .. p_current .. "] converted to [" .. p_new .. "] in position ".. i .. ".")
p_current = p_new
p_new = ""
end
local function p_RemoveNext()
table.remove(working_phones, i + 1)
update_p()
end
-- Resolution of [aù] --
if p_prev == "a" and p_current == "ù" then
-- mw.log("<aù> recognised in position " .. i .. ". Converting to resolvable [u].")
p_Convert("u")
p_current = "u"
end
-- Resolution of [u], [ù] and [ū] --
if p_current == "u" then
-- mw.log("[u] found in position " .. i .. ". Testing for resolution.")
if consonant[p_next] then
if glide[p_next2] then
if not vowel[p_next3] then
-- mw.log("ɤCj!V environment identified.")
p_Convert("ɤ")
else
-- mw.log("No resolution needed.")
end
elseif not vowel[p_next2] then
-- mw.log("ɤC!V environment identified.")
p_Convert("ɤ")
else
-- mw.log("No resolution needed.")
end
else
-- mw.log("No resolution needed.")
end
elseif p_current == "ù" or p_current == "ū" then
-- mw.log("Fixed [u] found in position " .. i .. ".")
p_Convert("u")
end
-- Resolution of <Vj> to diphthongs
if p_next == "j" and not vowel[p_next2] then
if p_current == "a" then
p_Resolve("ai")
p_RemoveNext()
elseif p_current == "ɤ" then
p_Resolve("ɤi")
p_RemoveNext()
elseif p_current == "ɛ" then
p_Resolve("ei")
p_RemoveNext()
elseif p_current == "ɔː" then
p_Resolve("ɔi")
p_RemoveNext()
end
end
-- Resolution of <ei> and  <øi> --
if p_current == "ei" then
for j = 1, i do
local check_phone = working_phones[i - j]
if boundary[check_phone] or check_phone == nil then
-- mw.log("Initial [ei] found in position" .. i .. ".")
p_Resolve("ai")
break
elseif not consonant[check_phone] then
break
end
end
end
if vowel[p_next] then
-- Resolution of prevocalic <iej>, <uoj> and <yej> --
if p_current == "iej" or p_current == "yej" or p_current == "uoj" then
-- mw.log("Pre-vocalic <" .. p_current .. "> found in position " .. i .. ".")
if p_current == "uoj" then
p_Resolve("uo")
table.insert(working_phones, i + 1, "j")
-- mw.log("[j] inserted to position " .. i + 1 .. ".")
update_p()
else
p_Resolve("iː")
end
end
-- Resolution of prevocalic [ie] and [uo] --
if p_current == "ie" then
p_Resolve("iː")
elseif p_current == "uo" and p_next ~= "j" then
p_Resolve("uː")
end
else
-- Resolution of non-prevocalic <iej>, <uoj> and <yej> --  
for toResolve, ResolveKey in pairs({["iej"] = "ei", ["uoj"] = "ɔi", ["yej"] = "øi"}) do
if p_current == toResolve then
p_Resolve(ResolveKey)
end
end
end


-- Resolution of [j] after [i]
    -- mw.log("Vowel resolution result: [" .. table.concat(working_phones,"][") .. "]")
    return working_phones
if p_current == "j" and (p_prev == "i" or p_prev == "iː" or p_prev == "iːː")  then
table.remove(working_phones, i)
i = i - 1
update_p()
end
end
-- Removes placeholder phones from data --
for _, temp in ipairs(vowel_temp) do
valid_phone[temp] = nil
vowel[temp] = nil
end
-- mw.log("Vowel resolution result: [" .. table.concat(working_phones,"][") .. "]")
return working_phones
end
end


function resolve_consonants(phones, hj_dv, phon)
function resolve_consonants(phones, hj_dv, phon)
local working_phones = phones
    local working_phones = phones
-- mw.log("————— BEGINNING CONSONANT RESOLUTION —————")
    -- mw.log("————— BEGINNING CONSONANT RESOLUTION —————")
 
    local i = 0
    while true do
        i = i + 1
        local p_prev = working_phones[i - 1]
        local p_current = working_phones[i]
        local p_next = working_phones[i + 1]
        local p_next2 = working_phones[i + 2]
        local p_next3 = working_phones[i + 3]
 
        if p_current == nil then
            break
        end
 
        local function p_Resolve(p_new)
            working_phones[i] = p_new
            -- mw.log("[" .. p_current .. "] resolved to [" .. p_new .. "] in position ".. i .. ".")
            p_new = ""
        end
 
        local function p_Convert(p_new)
            working_phones[i] = p_new
            -- mw.log("[" .. p_current .. "] converted to [" .. p_new .. "] in position ".. i .. ".")
            p_current = p_new
            p_new = ""
        end
 
        local function p_RemoveNext()
            table.remove(working_phones, i + 1)
            p_next = working_phones[i + 1]
            p_next2 = working_phones[i + 2]
            p_next3 = working_phones[i + 3]
        end
 
        -- Resolution of iotation --
 
        if iotate[p_current] and p_next == "j" then
            -- mw.log("[j] removed from position " .. i + 1 .. ".")
            -- mw.log("[" .. p_current .. "][j] found in position " .. i .. ".")
            p_Convert(iotate[p_current])
            p_RemoveNext()
        elseif p_current == "ĵ" then
            p_Convert("j")
        end
 
        -- Resolution of hjádvanþs --
 
        if not hj_dv then
            if p_current == "ç" then
                -- mw.log("hj = false:")
                p_Convert("ʃ")
            elseif p_current == "j" and (boundary[p_prev] or p_prev == nil) and consonant[p_next] then
                -- mw.log("hj = false:")
                p_Convert("ʒ")
            end
        end
 
        -- Resolution of (T)Ss, (T)Sș, ts, ds, tș, dș (progressive voicing assimilation) --
 
        if p_next == "s" then
            if sibilant[p_current] then
                -- mw.log("[s] removed from position " .. i + 1 .. " following a sibilant.")
                p_RemoveNext()
            elseif p_current == "t" then
                -- mw.log("[t][s] → [ts] in position " .. i .. ".")
                p_Convert("ts")
                p_RemoveNext()
            elseif p_current == "d" then
                p_Convert("dz")
                p_RemoveNext()
            -- mw.log("[d][s] → [dz] in position " .. i .. ".")
            end
        elseif p_next == "ʃ" then
            if sibilant_post[p_current] == true then
                -- mw.log("[ʃ] removed from position " .. i + 1 .. " following a postalveolar sibilant.")
                p_RemoveNext()
            elseif sibilant_alv[p_current] then
                -- mw.log("[" .. p_current .. "][ʃ] → [" .. sibilant_alv_to_post[p_current] .. "] in position " .. i .. ".")
                p_Convert(sibilant_alv_to_post[p_current])
                p_RemoveNext()
            elseif p_current == "t" then
                -- mw.log("[t][ʃ] → [tʃ] in position " .. i .. ".")
                p_Convert("tʃ")
                p_RemoveNext()
            elseif p_current == "d" then
                p_Convert("dʒ")
                p_RemoveNext()
            -- mw.log("[d][ʃ] → [dʒ] in position " .. i .. ".")
            end
        end
 
        -- Resolution of Cv --
 
        if p_next == "v" and ((Cv_split[p_current] and not vowel[p_prev]) or Cv_fixed[p_current]) then
            -- mw.log("Cluster [" .. p_current .. "][v] resolved to [" .. p_current .. "] at position " .. i .. ".")
            p_RemoveNext()
        end
 
        -- Resolution of regressive voicing assimilation --
 
        if obstruent[p_current] then
            -- mw.log("Obstruent [" .. p_current .. "] found in position " .. i .. ". Searching for cluster.")
            local final_i = i
 
            -- find voicing of final obstruent in cluster --
            for k = i + 1, #working_phones do
                local check_phone = working_phones[k]
                if obstruent[check_phone] and check_phone ~= "v" then -- /v/ is excluded
                    final_i = k
                else
                    break
                end
            end
 
            if final_i ~= i then -- if cluster recognised --
                final_obs = working_phones[final_i]
                -- mw.log("Final obstruent in cluster is [" .. final_obs .. "], cluster length " .. final_i - i + 1 .. ".")
 
                -- assimilate --
 
                if obstruent_voiced[p_current] ~= obstruent_voiced[final_obs] then
                    -- mw.log("Voicing mismatch found in cluster at position " .. i .. ".")
                    if obstruent_voiced[final_obs] == true then
                        p_Convert(obstruent_voice[p_current])
                    else
                        p_Convert(obstruent_devoice[p_current])
                    end
                else
                    -- mw.log("No voicing mismatch found.")
                end
            else
                -- mw.log("No cluster found.")
            end
        end
 
        -- tv and kv
        if p_current == "v" and (p_prev == "t" or p_prev == "k") then
            p_Convert("f")
        -- mw.log("[" .. p_prev .. "][v] → [" .. p_prev .. "][f] in position " .. i .. ".")
        end
 
        -- j + [i]
        local i_initial = {["i"] = true, ["iː"] = true, ["iːː"] = true, ["ie"] = true, ["iːe"] = true}
        if p_current == "j" and i_initial[p_next] then
            table.remove(working_phones, i)
            -- mw.log("[j] removed from position ".. i .. ".")
            p_current = working_phones[i]
        end
 
        -- [i] + j
        local i_oid = {["i"] = true, ["iː"] = true, ["iːː"] = true}
        if p_current == "j" and i_oid[p_prev] then
            table.remove(working_phones, i)
            -- mw.log("[j] removed from position ".. i .. ".")
            p_current = working_phones[i]
        end
 
        -- Resolution of geminates --


local i = 0
        if
while true do
            p_next == p_current and (boundary[p_next2] or p_next2 == nil or consonant[p_next2]) and p_next2 ~= "j" and
i = i + 1
                p_next2 ~= "w" and
local p_prev = working_phones[i - 1]
                consonant[p_current]
local p_current = working_phones[i]
        then
local p_next = working_phones[i + 1]
            p_RemoveNext()
local p_next2 = working_phones[i + 2]
        -- mw.log("Geminate [" .. p_current .. "] removed in coda position at position " .. i .. ".")
local p_next3 = working_phones[i + 3]
        end
 
if p_current == nil then break end
        -- Removal of apostrophes --
 
local function p_Resolve(p_new)
        if p_current == "'" then
working_phones[i] = p_new
            table.remove(working_phones, i)
-- mw.log("[" .. p_current .. "] resolved to [" .. p_new .. "] in position ".. i .. ".")
            -- mw.log("Apostrophe removed from position ".. i .. ".")
p_new = ""
            p_current = working_phones[i]
end
        end
 
local function p_Convert(p_new)
        -- PHONETIC RESOLUTION --
working_phones[i] = p_new
        if phon then
-- mw.log("[" .. p_current .. "] converted to [" .. p_new .. "] in position ".. i .. ".")
            -- Cv --
p_current = p_new
 
p_new = ""
            if p_current == "v" and obstruent[p_prev] and p_prev ~= "d" and p_prev ~= "g" then
end
                p_Resolve("ʋ")
            -- mw.log("[" .. p_prev .. "][ʋ] → [" .. p_prev .. "][ʋ] in position " .. i .. ".")
local function p_RemoveNext()
            end
table.remove(working_phones, i + 1)
 
p_next = working_phones[i + 1]
            if p_current == "h" and not vowel[p_next] then -- hC
p_next2 = working_phones[i + 2]
                -- mw.log("phon = true:")
p_next3 = working_phones[i + 3]
                p_Convert("x")
end
            elseif p_current == "h" and p_next == "j" then
                -- mw.log("phon = true:")
-- Resolution of iotation --
                p_Convert("ç")
                p_RemoveNext()
if iotate[p_current] and p_next == "j" then
            end
-- mw.log("[" .. p_current .. "][j] found in position " .. i .. ".")
 
p_Convert(iotate[p_current])
            if p_current == "n" and p_next == "j" then
p_RemoveNext()
                -- mw.log("phon = true:")
-- mw.log("[j] removed from position " .. i + 1 .. ".")
                p_Convert("ɲ")
elseif p_current == "ĵ" then
                p_RemoveNext()
p_Convert("j")
            end
end
 
            if p_current == "n" and p_next == "n" and p_next2 == "j" then
-- Resolution of hjádvanþs --
                -- mw.log("phon = true:")
                p_Convert("ɲ")
if not hj_dv then
            end
if p_current == "ç" then
            --
-- mw.log("hj = false:")
 
p_Convert("ʃ")
            --[[
elseif p_current == "j" and (boundary[p_prev] or p_prev == nil) and consonant[p_next] then
-- mw.log("hj = false:")
p_Convert("ʒ")
end
end
-- Resolution of (T)Ss, (T)Sș, ts, ds, tș, dș (progressive voicing assimilation) --
if p_next == "s" then
if sibilant[p_current] then
p_RemoveNext()
-- mw.log("[s] removed from position " .. i + 1 .. " following a sibilant.")
elseif p_current == "t" then
p_Convert("ts")
p_RemoveNext()
-- mw.log("[t][s] → [ts] in position " .. i .. ".")
elseif p_current == "d" then
p_Convert("dz")
p_RemoveNext()
-- mw.log("[d][s] → [dz] in position " .. i .. ".")
end
elseif p_next == "ʃ" then
if sibilant_post[p_current] == true then
p_RemoveNext()
-- mw.log("[ʃ] removed from position " .. i + 1 .. " following a postalveolar sibilant.")
elseif sibilant_alv[p_current] then
-- mw.log("[" .. p_current .. "][ʃ] → [" .. sibilant_alv_to_post[p_current] .. "] in position " .. i .. ".")
p_Convert(sibilant_alv_to_post[p_current])
p_RemoveNext()
elseif p_current == "t" then
p_Convert("tʃ")
p_RemoveNext()
-- mw.log("[t][ʃ] → [tʃ] in position " .. i .. ".")
elseif p_current == "d" then
p_Convert("dʒ")
p_RemoveNext()
-- mw.log("[d][ʃ] → [dʒ] in position " .. i .. ".")
end
end
-- Resolution of Cv --
if p_next == "v" and ((Cv_split[p_current] and not vowel[p_prev]) or Cv_fixed[p_current]) then
-- mw.log("Cluster [" .. p_current .. "][v] resolved to [" .. p_current .. "] at position " .. i .. ".")
p_RemoveNext()
end
-- Resolution of regressive voicing assimilation --
if obstruent[p_current] then
-- mw.log("Obstruent [" .. p_current .. "] found in position " .. i .. ". Searching for cluster.")
local final_i = i
-- find voicing of final obstruent in cluster --
for k = i + 1, #working_phones do
local check_phone = working_phones[k]
if obstruent[check_phone] and check_phone ~= "v" then -- /v/ is excluded
final_i = k
else
break
end
end
if final_i ~= i then -- if cluster recognised --
final_obs = working_phones[final_i]
-- mw.log("Final obstruent in cluster is [" .. final_obs .. "], cluster length " .. final_i - i + 1 .. ".")
-- assimilate --
if obstruent_voiced[p_current] ~= obstruent_voiced[final_obs] then
-- mw.log("Voicing mismatch found in cluster at position " .. i .. ".")
if obstruent_voiced[final_obs] == true then
p_Convert(obstruent_voice[p_current])
else
p_Convert(obstruent_devoice[p_current])
end
else
-- mw.log("No voicing mismatch found.")
end
else
-- mw.log("No cluster found.")
end
end
-- tv and kv
if p_current == "v" and (p_prev == "t" or p_prev == "k") then
p_Convert("f")
-- mw.log("[" .. p_prev .. "][v] → [" .. p_prev .. "][f] in position " .. i .. ".")
end
-- j + [i]
local i_initial = { ["i"] = true, ["iː"] = true, ["iːː"] = true, ["ie"] = true, ["iːe"] = true, }
if p_current == "j" and i_initial[p_next] then
table.remove(working_phones, i)
-- mw.log("[j] removed from position ".. i .. ".")
p_current = working_phones[i]
end
-- [i] + j
local i_oid = { ["i"] = true, ["iː"] = true, ["iːː"] = true }
if p_current == "j" and i_oid[p_prev] then
table.remove(working_phones, i)
-- mw.log("[j] removed from position ".. i .. ".")
p_current = working_phones[i]
end
-- Resolution of geminates --
if p_next == p_current and (boundary[p_next2] or p_next2 == nil or consonant[p_next2]) and p_next2 ~= "j" and p_next2 ~= "w" and consonant[p_current] then
p_RemoveNext()
-- mw.log("Geminate [" .. p_current .. "] removed in coda position at position " .. i .. ".")
end
-- Removal of apostrophes --  
if p_current == "'" then
table.remove(working_phones, i)
-- mw.log("Apostrophe removed from position ".. i .. ".")
p_current = working_phones[i]
end
-- PHONETIC RESOLUTION --
if phon then
-- Cv --
if p_current == "v" and obstruent[p_prev] and p_prev ~= "d" and p_prev ~= "g" then
p_Resolve("ʋ")
-- mw.log("[" .. p_prev .. "][ʋ] → [" .. p_prev .. "][ʋ] in position " .. i .. ".")
end
if p_current == "h" and not vowel[p_next] then -- hC
-- mw.log("phon = true:")
p_Convert("x")
elseif p_current == "h" and p_next == "j" then
-- mw.log("phon = true:")
p_Convert("ç")
p_RemoveNext()
end
if p_current == "n" and p_next == "j" then
-- mw.log("phon = true:")
p_Convert("ɲ")
p_RemoveNext()
end
if p_current == "n" and p_next == "n" and p_next2 == "j" then
-- mw.log("phon = true:")
p_Convert("ɲ")
end
--[[
if p_current == "r" and p_next == "s" then
if p_current == "r" and p_next == "s" then
Line 939: Line 1,218:
end
end
]]--
]] if
                p_current == "œ" and (p_next == "a" or p_next == "aː" or p_next == "aːː")
if p_current == "œ" and (p_next == "a" or p_next == "aː" or p_next == "aːː") then
            then
table.insert(working_phones, i+1, "w")
                table.insert(working_phones, i + 1, "w")
end
            end
        end
 
        -- Resolution of NK --
 
        if p_current == "n" and velar[p_next] then
            -- mw.log("n + velar cluster found.")
            p_Resolve("ŋ")
        end
 
        -- RESOLUTION OF MULTIPLE BOUNDARIES --
        if p_current == " " and p_next == "|" then
            p_Convert("|")
            p_RemoveNext()
        elseif p_current == " " and p_next == " " then
            p_RemoveNext()
        elseif p_current == "|" and (p_next == " " or p_next == "|") then
            p_RemoveNext()
        end
    end
 
    -- Removes placeholder phones from data --
 
    for _, temp in ipairs(consonant_temp) do
        valid_phone[temp] = nil
        consonant[temp] = nil
        glide[temp] = nil
    end


end
    -- mw.log("Consonant resolution result: [" .. table.concat(working_phones,"][") .. "]")
    return working_phones
-- Resolution of NK --
if p_current == "n" and velar[p_next] then
-- mw.log("n + velar cluster found.")
p_Resolve("ŋ")
end
-- RESOLUTION OF MULTIPLE BOUNDARIES --
if p_current == " " and p_next == "|" then
p_Convert("|")
p_RemoveNext()
elseif p_current == " " and p_next == " " then
p_RemoveNext()
elseif p_current == "|" and (p_next == " " or p_next == "|") then
p_RemoveNext()
end
end
-- Removes placeholder phones from data --
for _, temp in ipairs(consonant_temp) do
valid_phone[temp] = nil
consonant[temp] = nil
glide[temp] = nil
end
-- mw.log("Consonant resolution result: [" .. table.concat(working_phones,"][") .. "]")
return working_phones
end
end


function get_syllables(phones)
function get_syllables(phones)
local working_phones = phones
    local working_phones = phones
local syllables = {}
    local syllables = {}
local working_syllable = {
    local working_syllable = {
["onset"] = {},
        ["onset"] = {},
["nucleus"] = "",
        ["nucleus"] = "",
["coda"] = {},
        ["coda"] = {}
}
    }
local syllable_no = 1
    local syllable_no = 1
 
local function logSyllable()
    local function logSyllable()
local onset = ""
        local onset = ""
local coda = ""
        local coda = ""
 
if working_syllable["onset"] then
        if working_syllable["onset"] then
onset = table.concat(working_syllable["onset"], " ")
            onset = table.concat(working_syllable["onset"], " ")
end
        end
if working_syllable["coda"] then
        if working_syllable["coda"] then
coda = table.concat(working_syllable["coda"], " ")
            coda = table.concat(working_syllable["coda"], " ")
end
        end
 
-- mw.log( onset .. " [ " .. working_syllable["nucleus"] .. " ] " .. coda )
        -- mw.log( onset .. " [ " .. working_syllable["nucleus"] .. " ] " .. coda )
end
    end
 
-- mw.log("————— BUILDING SYLLABLES —————")
    -- mw.log("————— BUILDING SYLLABLES —————")
 
-- division into syllables --
    -- division into syllables --
while #working_phones > 0 do
    while #working_phones > 0 do
local p_current = working_phones[1]
        local p_current = working_phones[1]
local p_next = working_phones[2]
        local p_next = working_phones[2]
local p_next2 = working_phones[3]
        local p_next2 = working_phones[3]
local p_next3 = working_phones[4]
        local p_next3 = working_phones[4]
 
local function register_syllable(check)
        local function register_syllable(check)
if check == true and working_syllable["nucleus"] ~= "" then
            if check == true and working_syllable["nucleus"] ~= "" then
syllables[syllable_no] = working_syllable
                syllables[syllable_no] = working_syllable
if #syllables[syllable_no]["onset"] == 0 then
                if #syllables[syllable_no]["onset"] == 0 then
syllables[syllable_no]["onset"] = nil
                    syllables[syllable_no]["onset"] = nil
end
                end
if #syllables[syllable_no]["coda"] == 0 then
                if #syllables[syllable_no]["coda"] == 0 then
syllables[syllable_no]["coda"] = nil
                    syllables[syllable_no]["coda"] = nil
end
                end
-- mw.log("Syllable " .. syllable_no .. " registered:")
                -- mw.log("Syllable " .. syllable_no .. " registered:")
logSyllable()
                logSyllable()
-- mw.log("====================")
                -- mw.log("====================")
syllable_no = syllable_no + 1
                syllable_no = syllable_no + 1
working_syllable = {
                working_syllable = {
["onset"] = {},
                    ["onset"] = {},
["nucleus"] = "",
                    ["nucleus"] = "",
["coda"] = {},
                    ["coda"] = {}
}
                }
end
            end
end
        end
 
local function register_boundary(check)
        local function register_boundary(check)
if check == true then
            if check == true then
register_syllable(true)
                register_syllable(true)
syllables[syllable_no] = p_current
                syllables[syllable_no] = p_current
table.remove(working_phones, 1)
                table.remove(working_phones, 1)
-- mw.log("Boundary syllable " .. syllable_no .. " registered: '" .. p_current .. "'\n====================")
                -- mw.log("Boundary syllable " .. syllable_no .. " registered: '" .. p_current .. "'\n====================")
syllable_no = syllable_no + 1
                syllable_no = syllable_no + 1
end
            end
end
        end
 
local function register_phone(check)
        local function register_phone(check)
if check == true then
            if check == true then
if vowel[p_current] then
                if vowel[p_current] then
working_syllable["nucleus"] = p_current
                    -- mw.log("[" .. p_current .. "] is now the working nucleus.")
-- mw.log("[" .. p_current .. "] is now the working nucleus.")
                    working_syllable["nucleus"] = p_current
elseif consonant[p_current] then
                elseif consonant[p_current] then
local unit = ""
                    -- mw.log("[" .. p_current .. "] appended to the working " .. unit .. ".")
if working_syllable["nucleus"] == "" then
                    local unit = ""
unit = "onset"
                    if working_syllable["nucleus"] == "" then
else
                        unit = "onset"
unit = "coda"
                    else
end
                        unit = "coda"
table.insert(working_syllable[unit], p_current)
                    end
-- mw.log("[" .. p_current .. "] appended to the working " .. unit .. ".")
                    table.insert(working_syllable[unit], p_current)
else
                else
error("Invalid input for function register_phone")
                    error("Invalid input for function register_phone")
end
                end
table.remove(working_phones, 1)
                table.remove(working_phones, 1)
-- mw.log("Current working syllable:")
                -- mw.log("Current working syllable:")
-- logSyllable()
                -- logSyllable()
 
if #working_phones == 0 then
                if #working_phones == 0 then
register_syllable(true)
                    register_syllable(true)
end
                end
end
            end
end
        end
 
if consonant[p_current] then
        if consonant[p_current] then
if working_syllable["nucleus"] == "" then
            if working_syllable["nucleus"] == "" then
register_phone(true)
                register_phone(true)
else
            else
if vowel[p_next] or (glide[p_next] and vowel[p_next2]) then -- *C*(J)V
                if vowel[p_next] or (glide[p_next] and vowel[p_next2]) then -- *C*(J)V
register_syllable(true)
                    register_syllable(true)
register_phone(true)
                    register_phone(true)
elseif #working_syllable["coda"] > 0 then -- C | …
                elseif #working_syllable["coda"] > 0 then -- C | …
                    local function JV(check)
local function JV(check)
                        if check == true then
if check == true then
                            if vowel[p_next2] or (glide[p_next2] and vowel[p_next3]) then -- C | *C*l(J)V
if vowel[p_next2] or (glide[p_next2] and vowel[p_next3]) then -- C | *C*l(J)V
                                register_syllable(true)
register_syllable(true)
                                register_phone(true)
register_phone(true)
                            else
else
                                register_phone(true)
register_phone(true)
                            end
end
                        end
end
                    end
end
 
                    if Cl[p_current] and p_next == "l" then -- C | *C*l …
if Cl[p_current] and p_next == "l" then -- C | *C*l …
                        JV(true) -- C | *C*l(J)V
JV(true) -- C | *C*l(J)V
                    elseif Cr[p_current] and p_next == "r" then -- C | *C*r …
elseif Cr[p_current] and p_next == "r" then -- C | *C*r …
                        JV(true) -- C | *C*r(J)V
JV(true) -- C | *C*r(J)V
                    elseif Cv[p_current] and (p_next == "v" or p_next == "ʋ" or p_next == "f") then -- C | *C*v …
elseif Cv[p_current] and (p_next == "v" or p_next == "ʋ" or p_next == "f") then -- C | *C*v …
                        JV(true) -- C | *C*v(J)V
JV(true) -- C | *C*v(J)V
                    elseif CN[p_current] and nasal[p_next] then -- C | *C*N …
elseif CN[p_current] and nasal[p_next] then -- C | *C*N …
                        JV(true) -- C | *C*N(J)V
JV(true) -- C | *C*N(J)V
                    else
else
                        register_phone(true)
register_phone(true)
                    end
end
                else
else
                    register_phone(true)
register_phone(true)
                end
end
            end
end
        elseif vowel[p_current] then
elseif vowel[p_current] then
            if working_syllable["nucleus"] == "" then
if working_syllable["nucleus"] == "" then
                register_phone(true)
register_phone(true)
            else
else
                register_syllable(true)
register_syllable(true)
                register_phone(true)
register_phone(true)
            end
end
        elseif boundary[p_current] or p_current == "-" then
elseif boundary[p_current] or p_current == "-" then
            register_boundary(true)
register_boundary(true)
        else
else
            error("Unrecognised phone in syllabifier: " .. p_current)
error("Unrecognised phone in syllabifier: " .. p_current)
        end
end
    end
end
 
    -- mw.log("STRING EXHAUSTED\n====================")


-- mw.log("STRING EXHAUSTED\n====================")
    return syllables
return syllables
end
end


function tag_syllables(syllables)
function tag_syllables(syllables)
    -- mw.log("————— TAGGING SYLLABLES —————")


-- mw.log("————— TAGGING SYLLABLES —————")
    local syl_count = #syllables
 
local syl_count = #syllables
    for i = 1, syl_count do
        local syllable = syllables[i]
for i = 1, syl_count do
 
        local function tag_syllable(tag, value)
local syllable = syllables[i]
            syllables[i][tag] = value
            -- mw.log("syllables[" .. i .. "][" .. tag .. "] = " .. tostring(value) )
local function tag_syllable(tag, value)
        end
syllables[i][tag] = value
 
-- mw.log("syllables[" .. i .. "][" .. tag .. "] = " .. tostring(value) )
        -- tag checked syllables --
end
        if type(syllable) == "table" then
            if syllable["coda"] == nil then
-- tag checked syllables --
                tag_syllable("checked", false)
if type(syllable) == "table" then
            else
                tag_syllable("checked", true)
if syllable["coda"] == nil then
            end
tag_syllable("checked", false)
 
else
            -- tag long syllables --
tag_syllable("checked", true)
            if long[syllable["nucleus"]] then
end
                tag_syllable("long", true)
            else
-- tag long syllables --
                tag_syllable("long", false)
if long[syllable["nucleus"]] then
            end
tag_syllable("long", true)
 
else
            -- tag weak syllables (nucleus = [i] [ɤ]) --
tag_syllable("long", false)
            if weak[syllable["nucleus"]] then
end
                tag_syllable("weak", true)
            else
-- tag weak syllables (nucleus = [i] [ɤ]) --
                tag_syllable("weak", false)
if weak[syllable["nucleus"]] then
            end
tag_syllable("weak", true)
 
else
            -- tag heavy syllables (nucleus is long coda is an obstruent-initial cluster) -
tag_syllable("weak", false)
 
end
            if syllable["coda"] then
                if long[syllable["nucleus"]] and affricate[syllable["coda"][1]] then
-- tag heavy syllables (nucleus is long coda is an obstruent-initial cluster) -
                    tag_syllable("heavy", true)
                elseif long[syllable["nucleus"]] and obstruent[syllable["coda"][1]] and syllable["coda"][2] then
if syllable["coda"] then
                    tag_syllable("heavy", true)
if long[syllable["nucleus"]] and affricate[syllable["coda"][1]] then
                else
tag_syllable("heavy", true)
                    tag_syllable("heavy", false)
elseif long[syllable["nucleus"]] and obstruent[syllable["coda"][1]] and syllable["coda"][2] then
                end
tag_syllable("heavy", true)
            end
else
 
tag_syllable("heavy", false)
        -- mw.log("—————")
end
        end
end
    end


-- mw.log("—————")
    return syllables
end
end
return syllables
end
end


function get_stress(syllables)
function get_stress(syllables)
--[[
    --[[
Stress in Radestrian is calculated excluding · prefixes, which are stressed as if they were standalone words but with secondary stress. Stress in Radestrian falls on either the first syllable or the second syllable. The first syllable is the default stress position. Second-syllable stress occurs in seven circumstances:
Stress in Radestrian is calculated excluding · prefixes, which are stressed as if they were standalone words but with secondary stress. Stress in Radestrian falls on either the first syllable or the second syllable. The first syllable is the default stress position. Second-syllable stress occurs in seven circumstances:
Line 1,216: Line 1,485:
]]
]]
    local working_word = {}
local working_word = {}
    local output = {}
local output = {}
    local test_n = #syllables
local test_n = #syllables
 
    -- mw.log("————— BEGINNING STRESS ASSIGNMENT —————")
-- mw.log("————— BEGINNING STRESS ASSIGNMENT —————")
 
    while #syllables > 0 do
while #syllables > 0 do
        -- basically an iteration of working words
-- basically an iteration of working words
 
        if type(syllables[1]) == "table" then -- testing for boundary syllable
if type(syllables[1]) == "table" then -- testing for boundary syllable
            -- set up current working word by adding and removing the initial syllables from the array until a boundary is registered
            for i = 1, test_n do
-- set up current working word by adding and removing the initial syllables from the array until a boundary is registered
                table.insert(working_word, syllables[1])
for i = 1, test_n do
                table.remove(syllables, 1)
table.insert(working_word, syllables[1])
                -- mw.log("Syllable " .. i .. " registered to working word.")
table.remove(syllables, 1)
                if syllables[1] == nil or type(syllables[1]) == "string" then -- check next syllable is a boundary (now 1 after deletion of registered syllable)
-- mw.log("Syllable " .. i .. " registered to working word.")
                    -- mw.log("Boundary found: continuing to stress assignment.")
if syllables[1] == nil or type(syllables[1]) == "string" then -- check next syllable is a boundary (now 1 after deletion of registered syllable)
                    break
-- mw.log("Boundary found: continuing to stress assignment.")
                end -- if next syllable is a boundary, register and continue to stress assignment
break
            end
end -- if next syllable is a boundary, register and continue to stress assignment
 
end
            -- INTERNAL FUNCTIONS
 
-- INTERNAL FUNCTIONS
            local function stress(syl) -- assigns primary or secondary stress to the current working word
                if syl == 1 or syl == 2 then
local function stress(syl) -- assigns primary or secondary stress to the current working word
                    if
if syl == 1 or syl == 2 then
                        (syllables[1] == "-" or output[#output] == "·") and syllables[1] ~= "·" and
if (syllables[1] == "-" or output[#output] == "·") and syllables[1] ~= "·" and output[#output] ~= "-" then -- check if following · or preceding - ; if so, assign stress regardless of monosyllabicness
                            output[#output] ~= "-"
working_word[syl]["stress"] = true
                    then -- check if following · or preceding - ; if so, assign stress regardless of monosyllabicness
-- mw.log("Primary stress assigned to syllable " .. syl .. ".")
                        -- mw.log("Primary stress assigned to syllable " .. syl .. ".")
elseif #working_word > 1 then -- if monosyllabic, do not add a redundant stress mark
                        working_word[syl]["stress"] = true
if output[#output] == "-" or syllables[1] == "·" then -- check if following - or preceding ·
                    elseif #working_word > 1 then -- if monosyllabic, do not add a redundant stress mark
working_word[syl]["stress2"] = true
                        if output[#output] == "-" or syllables[1] == "·" then -- check if following - or preceding ·
-- mw.log("Secondary stress assigned to syllable " .. syl .. ".")
                            -- mw.log("Secondary stress assigned to syllable " .. syl .. ".")
else
                            working_word[syl]["stress2"] = true
working_word[syl]["stress"] = true
                        else
-- mw.log("Primary stress assigned to syllable " .. syl .. ".")
                            -- mw.log("Primary stress assigned to syllable " .. syl .. ".")
end
                            working_word[syl]["stress"] = true
else
                        end
-- mw.log("Implicit primary stress assigned to monosyllable.")
                    else
end
                        -- mw.log("Implicit primary stress assigned to monosyllable.")
                    end
-- register the working word
 
if #working_word > 0 then
                    -- register the working word
for j = 1, #working_word do
                    if #working_word > 0 then
table.insert(output, working_word[j])
                        -- mw.log("Word registered to output.")
end
                        for j = 1, #working_word do
working_word = {}
                            table.insert(output, working_word[j])
-- mw.log("Word registered to output.")
                        end
else
                        working_word = {}
error("An empty word cannot be registered")
                    else
end
                        error("An empty word cannot be registered")
else
                    end
error("Empty or invalid input to stress()")
                else
end
                    error("Empty or invalid input to stress()")
end
                end
            end
-- calculate stress on the working word
 
            -- calculate stress on the working word
-- mw.log("Syllables in working word: " .. #working_word)
 
            -- mw.log("Syllables in working word: " .. #working_word)
if #working_word == 0 or working_word == nil then
 
error("The working word is empty")
            if #working_word == 0 or working_word == nil then
                error("The working word is empty")
elseif
            elseif
#working_word == 1 or -- monosyllabic?
                #working_word == 1 or working_word[1]["long"] -- monosyllabic?
working_word[1]["long"] -- long initial
            then -- long initial
then
                stress(1)
stress(1)
            elseif #working_word == 2 then -- disyllabic?
                if working_word[1]["checked"] == false and working_word[2]["heavy"] then -- condition 1
elseif #working_word == 2 then -- disyllabic?
                    stress(2)
if working_word[1]["checked"] == false and working_word[2]["heavy"] then -- condition 1
                else
stress(2)
                    stress(1)
else
                end
stress(1)
            elseif #working_word == 3 then -- trisyllabic?
end
                if
                    working_word[2]["long"] or -- condition 2
elseif #working_word == 3 then -- trisyllabic?
                        ((not working_word[2]["weak"]) and working_word[2]["checked"]) -- condition 3
                then
if
                    stress(2)
working_word[2]["long"] or -- condition 2
                else
((not working_word[2]["weak"]) and working_word[2]["checked"]) -- condition 3
                    stress(1)
then
                end
stress(2)
            elseif #working_word >= 4 then -- 4+ syllables
else
                if
stress(1)
                    working_word[2]["long"] or -- condition 4
end
                        working_word[2]["checked"] or -- condition 5
                        not working_word[3]["long"] -- condition 6
elseif #working_word >= 4 then -- 4+ syllables
                then
                    stress(2)
if
                else
working_word[2]["long"] or -- condition 4
                    stress(1)
working_word[2]["checked"] or -- condition 5
                end
not working_word[3]["long"] -- condition 6
            else
then
                error("Invalid syllable count")
stress(2)
            end
else
        elseif syllables[1] == nil then
stress(1)
            error("Empty syllable found in array. The array should contain no empty syllables")
end
        else -- if boundary is identified as the working word, then
            -- mw.log ("Boundary syllable identified.")
else
            table.insert(output, syllables[1])
error("Invalid syllable count")
            -- mw.log("Boundary registered to output: [" .. syllables[1] .. "]")
end
            table.remove(syllables, 1)
        end
elseif syllables[1] == nil then
 
error("Empty syllable found in array. The array should contain no empty syllables")
        -- mw.log("—————")
else -- if boundary is identified as the working word, then
    end
-- mw.log ("Boundary syllable identified.")
 
table.insert(output, syllables[1])
    -- mw.log("SYLLABLES EXHAUSTED\n==========\nRemoving [·] and [-] from the system.")
-- mw.log("Boundary registered to output: [" .. syllables[1] .. "]")
 
table.remove(syllables, 1)
    local screened = false
end
    while screened == false do
        for i = 1, #output do
-- mw.log("—————")
            if output[i] == "-" or output[i] == "·" then
                table.remove(output, i)
end
                break
            elseif i == #output then
-- mw.log("SYLLABLES EXHAUSTED\n==========\nRemoving [·] and [-] from the system.")
                screened = true
            end
local screened = false
        end
while screened == false do
    end
for i = 1, #output do
 
if output[i] == "-" or output[i] == "·" then
    return output
table.remove(output, i)
break
elseif i == #output then
screened = true
end
end
end
return output
end
end


function resolve_syllables(syllables)
function resolve_syllables(syllables)
    -- mw.log("————— RESOLVING SYLLABLES —————")
    if #syllables > 1 then
        for i = 1, #syllables - 1 do
            local working_cluster = {}
            if
                (syllables[i]["coda"] or syllables[i + 1]["onset"]) and syllables[i + 1] and
                    type(syllables[i]) == "table" and
                    type(syllables[i + 1]) == "table"
            then
                -- mw.log("Resolving clusters in syllables " .. i .. " and " .. i + 1 .. ".")
                -- get intersyllabic clusters --
                if syllables[i]["coda"] then
                    for j = 1, #syllables[i]["coda"] do
                        table.insert(working_cluster, syllables[i]["coda"][j])
                    end
                end
                if syllables[i + 1]["onset"] then
                    for j = 1, #syllables[i + 1]["onset"] do
                        table.insert(working_cluster, syllables[i + 1]["onset"][j])
                    end
                end
                -- mw.log("Cluster to be resolved: " .. table.concat(working_cluster))
                local p_last = working_cluster[#working_cluster]
                local p_last2 = working_cluster[#working_cluster - 1]
                local p_last3 = working_cluster[#working_cluster - 2]
                local p_last4 = working_cluster[#working_cluster - 3]
                local new_coda = {}
                local new_onset = {}
                -- splits the current cluster into new coda and new onset and re-assigns them to the syllables --
                local function split(point)
                    if point < 1 or point > 3 or point == nil then
                        error("split() must take integer values between 1 to 4 inclusive")
                    end
                    for j = #working_cluster + 1 - point, #working_cluster do
                        table.insert(new_onset, working_cluster[j])
                    end
                    if #working_cluster - point > 0 then
                        for j = 1, #working_cluster - point do
                            table.insert(new_coda, working_cluster[j])
                        end
                    end
                    -- mw.log("σ" .. i .. " | σ" .. i+1 .. " : … " .. table.concat(new_coda) .. " | " .. table.concat(new_onset) .. " …")
                    syllables[i]["coda"] = new_coda
                    syllables[i + 1]["onset"] = new_onset
                end
                -- determine syllable boundary --
                if glide[p_last] and nasal[p_last2] and CN[p_last3] and p_last4 then -- C|CNJ
                    split(3)
                elseif nasal[p_last] and CN[p_last2] and p_last3 then -- C|CN
                    split(2)
                elseif glide[p_last] and p_last2 == "r" and Cr[p_last3] and p_last4 then -- C|CrJ
                    split(3)
                elseif p_last == "r" and Cr[p_last2] and p_last3 then -- C|Cr
                    split(2)
                elseif glide[p_last] and p_last2 == "l" and Cl[p_last3] and p_last4 then -- C|ClJ
                    split(3)
                elseif p_last == "l" and Cl[p_last2] and p_last3 then -- C|Cl
                    split(2)
                elseif
                    glide[p_last] and (p_last2 == "v" or p_last2 == "ʋ" or p_last2 == "f") and Cv[p_last3] and p_last4
                then -- C|CvJ
                    split(3)
                elseif (p_last == "v" or p_last == "ʋ" or p_last == "f") and Cv[p_last2] and p_last3 then -- C|Cv
                    split(2)
                elseif glide[p_last] and p_last2 then -- C|CJ
                    split(2)
                else -- C|C
                    split(1)
                end
            end
        end
    end


-- mw.log("————— RESOLVING SYLLABLES —————")
    return syllables
if #syllables > 1 then
for i = 1, #syllables - 1 do
local working_cluster = {}
if (syllables[i]["coda"] or syllables[i+1]["onset"]) and syllables[i+1] and type(syllables[i]) == "table" and type(syllables[i+1]) == "table" then
-- mw.log("Resolving clusters in syllables " .. i .. " and " .. i + 1 .. ".")
-- get intersyllabic clusters --
if syllables[i]["coda"] then
for j = 1, #syllables[i]["coda"] do
table.insert(working_cluster, syllables[i]["coda"][j])
end
end
if syllables[i+1]["onset"] then
for j = 1, #syllables[i+1]["onset"] do
table.insert(working_cluster, syllables[i+1]["onset"][j])
end
end
-- mw.log("Cluster to be resolved: " .. table.concat(working_cluster))
local p_last = working_cluster[#working_cluster]
local p_last2 = working_cluster[#working_cluster-1]
local p_last3 = working_cluster[#working_cluster-2]
local p_last4 = working_cluster[#working_cluster-3]
local new_coda = {}
local new_onset = {}
-- splits the current cluster into new coda and new onset and re-assigns them to the syllables --
local function split(point)
if point < 1 or point > 3 or point == nil then
error("split() must take integer values between 1 to 4 inclusive")
end
for j = #working_cluster + 1 - point, #working_cluster do
table.insert(new_onset, working_cluster[j])
end
if #working_cluster - point > 0 then
for j = 1, #working_cluster - point do
table.insert(new_coda, working_cluster[j])
end
end
-- mw.log("σ" .. i .. " | σ" .. i+1 .. " : … " .. table.concat(new_coda) .. " | " .. table.concat(new_onset) .. " …")
syllables[i]["coda"] = new_coda
syllables[i+1]["onset"] = new_onset
end
-- determine syllable boundary --
if glide[p_last] and nasal[p_last2] and CN[p_last3] and p_last4 then -- C|CNJ
split(3)
elseif nasal[p_last] and CN[p_last2] and p_last3 then -- C|CN
split(2)
elseif glide[p_last] and p_last2 == "r" and Cr[p_last3] and p_last4 then -- C|CrJ
split(3)
elseif p_last == "r" and Cr[p_last2] and p_last3 then -- C|Cr
split(2)
elseif glide[p_last] and p_last2 == "l" and Cl[p_last3] and p_last4 then -- C|ClJ
split(3)
elseif p_last == "l" and Cl[p_last2] and p_last3 then -- C|Cl
split(2)
elseif glide[p_last] and (p_last2 == "v" or p_last2 == "ʋ" or p_last2 == "f") and Cv[p_last3] and p_last4 then -- C|CvJ
split(3)
elseif (p_last == "v" or p_last == "ʋ" or p_last == "f") and Cv[p_last2] and p_last3 then -- C|Cv
split(2)
elseif glide[p_last] and p_last2 then -- C|CJ
split(2)
else -- C|C
split(1)
end
end
end
end
return syllables
end
end


function syllables_to_string(syllables, phon)
function syllables_to_string(syllables, phon)
    local output = ""
    -- mw.log("————— COMPILING OUTPUT —————")
    for i = 1, #syllables do
        local onset = ""
        local coda = ""
        local stress = ""


local output = ""
        -- add hiatus marker --
        if syllables[i + 1] then
-- mw.log("————— COMPILING OUTPUT —————")
            if
                syllables[i]["coda"] == nil and marked_hiatus[syllables[i]["nucleus"]] and
for i = 1, #syllables do
                    syllables[i + 1]["onset"] == nil and
local onset = ""
                    type(syllables[i + 1]) == "table"
local coda = ""
            then
local stress =""
                if not (syllables[i + 1]["stress"] or syllables[i + 1]["stress2"]) then
                    syllables[i]["coda"] = {"."}
-- add hiatus marker --
                -- mw.log("Hiatus marked between syllables " .. i .. " and " .. i+1 .. ".")
if syllables[i+1] then
                end
if syllables[i]["coda"] == nil and marked_hiatus[syllables[i]["nucleus"]] and syllables[i+1]["onset"] == nil and type(syllables[i+1]) == "table" then
            end
if not (syllables[i+1]["stress"] or syllables[i+1]["stress2"]) then
        end
syllables[i]["coda"] = {"."}
 
-- mw.log("Hiatus marked between syllables " .. i .. " and " .. i+1 .. ".")
        -- phonetic /a/ backing --
end
        if phon then
end
            if syllables[i]["nucleus"] == "a" then
end
                if syllables[i + 1] then
                    if syllables[i + 1]["nucleus"] == "æː" then
-- phonetic /a/ backing --
                        syllables[i]["nucleus"] = "ɑ"
if phon then
                    end
if syllables[i]["nucleus"] == "a" then
                end
if syllables[i+1] then
                if syllables[i - 1] then
if syllables[i+1]["nucleus"] == "æː" then
                    if syllables[i - 1]["nucleus"] == "æː" then
syllables[i]["nucleus"] = "ɑ"
                        syllables[i]["nucleus"] = "ɑ"
end
                    end
end
                end
if syllables[i-1] then
            --[[
if syllables[i-1]["nucleus"] == "æː" then
syllables[i]["nucleus"] = "ɑ"
end
end
--[[
if syllables[i]["nucleus"] == "a" then
if syllables[i]["nucleus"] == "a" then
syllables[i]["nucleus"] = "ä"
syllables[i]["nucleus"] = "ä"
end
end
]]--
]]
end
            --
--[[
            end
        --[[
if syllables[i]["nucleus"] == "ai" then
if syllables[i]["nucleus"] == "ai" then
syllables[i]["nucleus"] = "äi"
syllables[i]["nucleus"] = "äi"
Line 1,487: Line 1,751:
syllables[i]["nucleus"] = "uɐ"
syllables[i]["nucleus"] = "uɐ"
end
end
]]--
]]
end
        --
        end
-- gemination
 
        -- gemination
if phon and syllables[i] and syllables[i+1] then
 
if syllables[i]["coda"] and syllables[i+1]["onset"] then
        if phon and syllables[i] and syllables[i + 1] then
if syllables[i]["coda"][#syllables[i]["coda"]] == syllables[i+1]["onset"][1] then
            if syllables[i]["coda"] and syllables[i + 1]["onset"] then
table.remove(syllables[i]["coda"], #syllables[i]["coda"])
                if syllables[i]["coda"][#syllables[i]["coda"]] == syllables[i + 1]["onset"][1] then
syllables[i+1]["onset"][1] = syllables[i+1]["onset"][1] .. "ː"
                    table.remove(syllables[i]["coda"], #syllables[i]["coda"])
end
                    syllables[i + 1]["onset"][1] = syllables[i + 1]["onset"][1] .. "ː"
end
                end
end
            end
        end
-- phonetic nasalisation --
 
if phon and syllables[i]["coda"] then
        -- phonetic nasalisation --
        if phon and syllables[i]["coda"] then
local function get_nasal(check)
            local function get_nasal(check)
if check then
                if check then
-- mw.log("Phonetic nasalisation in syllable " .. i .. ": " .. syllables[i]["nucleus"] .. " → " .. nasalise[syllables[i]["nucleus"]])
                    -- mw.log("Phonetic nasalisation in syllable " .. i .. ": " .. syllables[i]["nucleus"] .. " → " .. nasalise[syllables[i]["nucleus"]])
syllables[i]["nucleus"] = nasalise[syllables[i]["nucleus"]]
                    syllables[i]["nucleus"] = nasalise[syllables[i]["nucleus"]]
table.remove(syllables[i]["coda"], 1)
                    table.remove(syllables[i]["coda"], 1)
end
                end
end
            end
 
if syllables[i]["coda"][1] == "ɲ" then
            if syllables[i]["coda"][1] == "ɲ" then
                if fricative[syllables[i]["coda"][2]] then
if fricative[syllables[i]["coda"][2]] then
                    get_nasal(true)
get_nasal(true)
                    table.insert(syllables[i]["coda"], 1, "j̃")
table.insert(syllables[i]["coda"], 1, "j̃")
                elseif syllables[i + 1] then
elseif syllables[i+1] then
                    if syllables[i + 1]["onset"] then
if syllables[i+1]["onset"] then
                        if syllables[i]["coda"][2] == nil and fricative[syllables[i + 1]["onset"][1]] then
if syllables[i]["coda"][2] == nil and fricative[syllables[i+1]["onset"][1]] then
                            get_nasal(true)
get_nasal(true)
                            table.insert(syllables[i]["coda"], 1, "j̃")
table.insert(syllables[i]["coda"], 1, "j̃")
                        end
end
                    end
end
                end
end
            elseif syllables[i]["coda"][1] == "n" then
                if fricative[syllables[i]["coda"][2]] then
elseif syllables[i]["coda"][1] == "n" then
                    get_nasal(true)
                elseif syllables[i + 1] then
if fricative[syllables[i]["coda"][2]] then
                    if syllables[i + 1]["onset"] then
get_nasal(true)
                        if syllables[i]["coda"][2] == nil and fricative[syllables[i + 1]["onset"][1]] then
elseif syllables[i+1] then
                            get_nasal(true)
if syllables[i+1]["onset"] then
                        end
if syllables[i]["coda"][2] == nil and fricative[syllables[i+1]["onset"][1]] then
                    end
get_nasal(true)
                end
end
            elseif syllables[i]["coda"][1] == "ŋ" then
end
                if syllables[i]["coda"][2] == "h" or syllables[i]["coda"][2] == "x" or syllables[i]["coda"][2] == "ɣ" then
end
                    get_nasal(true)
                elseif syllables[i + 1] then
elseif syllables[i]["coda"][1] == "ŋ" then
                    if syllables[i + 1]["onset"] then
                        if
if syllables[i]["coda"][2] == "h" or syllables[i]["coda"][2] == "x" or syllables[i]["coda"][2] == "ɣ" then
                            syllables[i]["coda"][2] == nil and
get_nasal(true)
                                (syllables[i + 1]["onset"][1] == "h" or syllables[i + 1]["onset"][1] == "x" or
elseif syllables[i+1] then
                                    syllables[i + 1]["onset"][1] == "ɣ")
if syllables[i+1]["onset"] then
                        then
if syllables[i]["coda"][2] == nil and (syllables[i+1]["onset"][1] == "h" or syllables[i+1]["onset"][1] == "x" or syllables[i+1]["onset"][1] == "ɣ") then
                            get_nasal(true)
get_nasal(true)
                        end
end
                    end
end
                end
end
            end
        end
end
 
end
        if type(syllables[i]) == "table" then
            if syllables[i]["onset"] then
if type(syllables[i]) == "table" then
                onset = table.concat(syllables[i]["onset"])
            end
if syllables[i]["onset"] then
 
onset = table.concat(syllables[i]["onset"])
            if syllables[i]["coda"] then
end
                coda = table.concat(syllables[i]["coda"])
            end
if syllables[i]["coda"] then
 
coda = table.concat(syllables[i]["coda"])
            if syllables[i]["stress"] then
end
                stress = "ˈ"
            end
if syllables[i]["stress"] then
 
stress = "ˈ"
            if syllables[i]["stress2"] then
end
                stress = "ˌ"
            end
if syllables[i]["stress2"] then
 
stress = "ˌ"
            output = output .. stress .. onset .. syllables[i]["nucleus"] .. coda
end
        elseif syllables[i] == " " then
            output = output .. " "
output = output .. stress .. onset .. syllables[i]["nucleus"] .. coda
        elseif syllables[i] == "|" then
elseif syllables[i] == " " then
            output = output .. " | "
output = output .. " "
        elseif syllables[i] == "‿" then
elseif syllables[i] == "|" then
            output = output .. "‿"
output = output .. " | "
        else
elseif syllables[i] == "‿" then
            error("Unknown phone identified: " .. syllables[i])
output = output .. "‿"
        end
else
    end
error("Unknown phone identified: " .. syllables[i])
 
end
    -- post rectifications --
    output = mw.ustring.gsub(output, "(ˈˌ)", "ˌ")
end
    -- vowel length resolution
 
-- post rectifications --
    output = mw.ustring.gsub(output, "i%.iː?e", "iːe")
output = mw.ustring.gsub(output, "(ˈˌ)", "ˌ")
    output = mw.ustring.gsub(output, "i%.iːː?", "iːː")
-- vowel length resolution
    output = mw.ustring.gsub(output, "i%.i", "iː")
    output = mw.ustring.gsub(output, "iːiː?e", "iːe")
output = mw.ustring.gsub(output, "i%.iː?e", "iːe")
    output = mw.ustring.gsub(output, "iːiː*", "iːː")
output = mw.ustring.gsub(output, "i%.iːː?", "iːː")
 
output = mw.ustring.gsub(output, "i%.i", "iː")
    output = mw.ustring.gsub(output, "u%.uː?o", "uːo")
output = mw.ustring.gsub(output, "iːiː?e", "iːe")
    output = mw.ustring.gsub(output, "u%.uːː?", "uːː")
output = mw.ustring.gsub(output, "iːiː*", "iːː")
    output = mw.ustring.gsub(output, "u%.u", "uː")
    output = mw.ustring.gsub(output, "uːuː?o", "uːo")
output = mw.ustring.gsub(output, "u%.uː?o", "uːo")
    output = mw.ustring.gsub(output, "uːuː*", "uːː")
output = mw.ustring.gsub(output, "u%.uːː?", "uːː")
 
output = mw.ustring.gsub(output, "u%.u", "uː")
    output = mw.ustring.gsub(output, "([^œɔui])a%.aːː?", "%1aːː")
output = mw.ustring.gsub(output, "uːuː?o", "uːo")
    output = mw.ustring.gsub(output, "([^œɔui])a%.a([^iu])", "%1aː%2")
output = mw.ustring.gsub(output, "uːuː*", "uːː")
    output = mw.ustring.gsub(output, "aːaː*", "aːː")
 
output = mw.ustring.gsub(output, "([^œɔui])a%.aːː?", "%1aːː")
    return output
output = mw.ustring.gsub(output, "([^œɔui])a%.a([^iu])", "%1aː%2")
output = mw.ustring.gsub(output, "aːaː*", "aːː")
return output  
end
end


function export.get_rhyme(IPA)
function export.get_rhyme(IPA)
if mw.ustring.find(IPA, "([ %|])") then
    if mw.ustring.find(IPA, "([ %|])") then
return nil
        return nil
end
    end
if mw.ustring.find(IPA, "(ˈ)") then
    if mw.ustring.find(IPA, "(ˈ)") then
IPA = mw.ustring.gsub(IPA, "(ˌ)", "")
        IPA = mw.ustring.gsub(IPA, "(ˌ)", "")
IPA = mw.ustring.gsub(IPA, "^(.*ˈ)", "")
        IPA = mw.ustring.gsub(IPA, "^(.*ˈ)", "")
end
    end
while true do
    while true do
local check = mw.ustring.sub(IPA, 1, 1)
        local check = mw.ustring.sub(IPA, 1, 1)
if consonant[check] then
        if consonant[check] then
IPA = mw.ustring.sub(IPA, 2)
            IPA = mw.ustring.sub(IPA, 2)
else
        else
break
            break
end
        end
end
    end
return IPA
    return IPA
end
end


function export.generate(frame)
function export.generate(frame)
local args = getArgs(frame)
    local args = getArgs(frame)
local outputIPA = args[1]
    local outputIPA = args[1]
 
local parameters = {}
    local parameters = {}
local p = 2
    local p = 2
 
-- mw.log("——— Parameters ———")
    -- mw.log("——— Parameters ———")
while args[p] do
    while args[p] do
parameters[args[p]] = true
        parameters[args[p]] = true
-- mw.log(args[p] .. " = true")
        -- mw.log(args[p] .. " = true")
p = p + 1
        p = p + 1
end
    end
 
process_temp()
    process_temp()
 
outputIPA = mw.ustring.gsub(outputIPA, "(%&nbsp%;)", " ")
    outputIPA = mw.ustring.gsub(outputIPA, "(%&nbsp%;)", " ")
 
local is_prefix = mw.ustring.sub(outputIPA, -1) == "-" or mw.ustring.sub(outputIPA, -1) == "·"
    local is_prefix = mw.ustring.sub(outputIPA, -1) == "-" or mw.ustring.sub(outputIPA, -1) == "·"
local is_suffix = mw.ustring.sub(outputIPA, 1, 1) == "-"
    local is_suffix = mw.ustring.sub(outputIPA, 1, 1) == "-"
 
outputIPA = generate_IPA(outputIPA)
    outputIPA = generate_IPA(outputIPA)
outputIPA = resolve_vowels(outputIPA)
    outputIPA = resolve_vowels(outputIPA)
outputIPA = resolve_consonants(outputIPA, parameters["hj"], parameters["phon"])
    outputIPA = resolve_consonants(outputIPA, parameters["hj"], parameters["phon"])
outputIPA = get_syllables(outputIPA)
    outputIPA = get_syllables(outputIPA)
outputIPA = tag_syllables(outputIPA)
    outputIPA = tag_syllables(outputIPA)
outputIPA = get_stress(outputIPA)
    outputIPA = get_stress(outputIPA)
outputIPA = resolve_syllables(outputIPA)
    outputIPA = resolve_syllables(outputIPA)
outputIPA = syllables_to_string(outputIPA, parameters["phon"])
    outputIPA = syllables_to_string(outputIPA, parameters["phon"])
 
if parameters["rhyme"] then
    if parameters["rhyme"] then
outputIPA = export.get_rhyme(outputIPA)
        outputIPA = export.get_rhyme(outputIPA)
end
    end
 
if outputIPA == nil then
    if outputIPA == nil then
        -- mw.log("Invalid rhyme request.")
-- mw.log("Invalid rhyme request.")
        return nil
return nil
    else
        if is_prefix then
else
            outputIPA = outputIPA .. "-"
        end
if is_prefix then
        if is_suffix then
outputIPA = outputIPA .. "-"
            outputIPA = "-" .. outputIPA
end
            outputIPA = mw.ustring.gsub(outputIPA, "(ˌ)", "")
if is_suffix then
        end
outputIPA = "-" .. outputIPA
 
outputIPA = mw.ustring.gsub(outputIPA, "(ˌ)", "")
        local nolarge = ""
end
        if parameters["nolarge"] then
            nolarge = " nolarge"
local nolarge = ""
        end
if parameters["nolarge"] then
        if parameters["phon"] and parameters["format"] then
nolarge = " nolarge"
            outputIPA = '<span class="IPA' .. nolarge .. '">[' .. outputIPA .. "]</span>"
end
        elseif parameters["format"] then
if parameters["phon"] and parameters["format"] then
            outputIPA = '<span class="IPA' .. nolarge .. '">/' .. outputIPA .. "/</span>"
outputIPA = "<span class=\"IPA" .. nolarge .. "\">[" .. outputIPA .. "]</span>"
        end
elseif parameters["format"] then
 
outputIPA = "<span class=\"IPA" .. nolarge .. "\">/" .. outputIPA .. "/</span>"
        -- mw.log(outputIPA)
end
        return outputIPA
    end
-- mw.log(outputIPA)
return outputIPA
end
end
end


Retrieved from ‘https://wiki.laenkea.si/wiki/Special:MobileDiff/21662’