Module:affix: Difference between revisions

local m_str_utils = require("Module:string utilities")

local m_table = require("Module:table")

local etymology_module = "Module:etymology"

local pron_qualifier_module = "Module:pron qualifier"

local scripts_module = "Module:scripts"

local utilities_module = "Module:utilities"

export.affix_lang_data_module_prefix = "Module:affix/lang-data/"

local rfind = m_str_utils.find

local rmatch = m_str_utils.match

local u = m_str_utils.char

local ucfirst = m_str_utils.ucfirst

export.langs_with_lang_specific_data = {

["az"] = true,

["fi"] = true,

["izh"] = true,

["la"] = true,

["sah"] = true,

["tr"] = true,

}

===About different types of affixes ("template", "display", "link", "lookup" and "category"):===

* A "display affix" is the corresponding affix as it is actually displayed to the user. The display affix may differ

   from the template affix for various reasons:

     languages have differences between the "template hyphen" specified in the template (which always needs to be

specified somehow or other in templates like {{tl|affix}}, to indicate that the term is an affix and what type of

* A (regular) "link affix" is the affix that is linked to when the affix is shown to the user. The link affix is usually

   the same as the display affix, but will differ in one of three circumstances:

     inline modifiers or piped links, as described above under "display affix".

   *# For certain languages, certain affixes are mapped to canonical form using language-specific mappings. For example,

   may strip certain diacritics: e.g. macrons in Latin and Old English (indicating length); acute and grave accents in

   Russian and various other Slavic languages (indicating stress); vowel diacritics in most Arabic-script languages; and

link.

   *# If no entry is found, the affix is then looked up in a modified link form (specifically, the modified display

lookup hyphen re-added if it was stripped out, as in the case of tatweel in many Arabic-script languages).

   The reason for this double lookup procedure is to allow for mappings that are sensitive to the extra diacritics, but

   unstressed, but is the same prefix either way).

]==]

local ZWNJ = u(0x200C) -- zero-width non-joiner

local template_hyphens = {

["Arab"] = "ـ" .. ZWNJ .. "-", -- tatweel + zero-width non-joiner + regular hyphen

["Hebr"] = "־", -- Hebrew-specific hyphen termed "maqqef"

["Mong"] = "᠊",

-- FIXME! What about the following right-to-left scripts?

-- Adlm (Adlam)

["Thaa"] = no_display_hyphen,

["Thai"] = no_display_hyphen,

}

local function glossary_link(entry, text)

text = text or entry

end

for i, cat in ipairs(data.categories) do

if type(cat) == "table" then

lang, cat.sort_key, cat.sort_base, force_cat)

else

data.data.sort_key, nil, force_cat)

end

cattext = table.concat(data.categories)

end

local q = data.data.q

local qq = data.data.qq

local l = data.data.l

local ll = data.data.ll

result = require(pron_qualifier_module).format_qualifiers {

lang = lang,

l = l,

ll = ll,

}

end

return result .. cattext

end

end

to access information for constructing the categories added by `format_derived()`.

]==]

local result

result = require(etymology_module).format_derived {

lang = data.lang,

sort_key = data.sort_key,

nocat = data.nocat,

borrowing_type = data.borrowing_type,

force_cat = data.force_cat or debug_force_cat,

}

else

end

end

end

end

return term

elseif affix_type == "circumfix" then

if mapping then

if type(mapping) == "table" then

if mapping then

return mapping

end

end

--[==[

For a given template term in a given language (see the definition of "template affix" near the top of the file),

]==]

local function parse_term_for_affixes(term, lang, sc, affix_type, do_affix_mapping, return_lookup_affix, affix_id)

if not term then

end

if term:find("^%^") then

end

thyph = "([" .. thyph .. "])"

if rfind(term, thyph .. " " .. thyph) then

affix_type = "circumfix"

local has_ending_hyphen = rfind(term, thyph .. "$")

if has_beginning_hyphen and has_ending_hyphen then

elseif has_ending_hyphen then

affix_type = "prefix"

elseif has_beginning_hyphen then

affix_type = "suffix"

end

end

local link_term, display_term, lookup_term

display_term = reconstruct_term_per_hyphens(term, affix_type, scode, thyph, dhyph)

if do_affix_mapping then

lookup_term = display_term

end

end

is of the wrong type). Three values are returned: the link term, display term and lookup term. This function is a thin

wrapper around `parse_term_for_affixes`; see the comments above that function for more information. Note that this

]==]

function export.make_affix(term, lang, sc, affix_type, do_affix_mapping, return_lookup_affix, affix_id)

if not (affix_type == "prefix" or affix_type == "suffix" or affix_type == "circumfix" or affix_type == "infix" or

error("Internal error: Invalid affix type " .. (affix_type or "(nil)"))

end

--[==[

]==]

data.pos = data.pos or default_pos

data.pos = pluralize(data.pos)

-- Process each part

local whole_words = 0

local is_affix_or_compound = false

data.parts[i] = part

canonicalize_part(part, data.lang, data.sc)

-- Determine affix type and get link and display terms (see text at top of file). Store them in the part

-- (in fields that won't clash with fields used by full_link() in [[Module:links]] or link_term()), so they

-- can be used in the loop below when categorizing.

part.affix_type, part.affix_link_term, part.affix_display_term = parse_term_for_affixes(part.term,

-- If link_term is an empty string, either a bare ^ was specified or an empty term was used along with inline

-- redundant alt text.

part.alt = part.alt or (part.affix_display_term ~= part.affix_link_term and part.affix_display_term) or nil

end

end

end

end

text = ucfirst(text)

end

table.insert(text_sections, 1, text)

end

table.insert(text_sections, export.join_formatted_parts { data = data, parts_formatted = parts_formatted,

return table.concat(text_sections)

end

function export.show_surface_analysis(data)

data.surface_analysis = true

return export.show_affix(data)

end

]==]

function export.show_compound(data)

data.pos = data.pos or default_pos

data.pos = pluralize(data.pos)

process_etymology_type(data.type, data.nocap, data.notext, #data.parts > 0)

data.borrowing_type = borrowing_type

local parts_formatted = {}

table.insert(categories, "compound " .. data.pos)

-- Determine affix type and get link and display terms (see text at top of file).

local affix_type, link_term, display_term = parse_term_for_affixes(part.term, part.lang, part.sc,

-- If link_term is an empty string, either a bare ^ was specified or an empty term was used along with

-- inline modifiers. The intention in either case is not to link the term. Don't add a '*fixed with'

-- redundant alt text.

if link_term and link_term ~= "" and not part.part_lang then

end

part.term = link_term ~= "" and link_term or nil

part.alt = part.alt or (display_term ~= link_term and display_term) or nil

else

local langcode = data.lang:getCode()

local full_langcode = data.lang:getFullCode()

else

whole_words = whole_words + 1

end

end

end

table.insert(text_sections, export.join_formatted_parts { data = data, parts_formatted = parts_formatted,

return table.concat(text_sections)

end

]==]

function export.show_compound_like(data)

if data.cat then

end

end

if data.text then

end

table.insert(text_sections, export.join_formatted_parts { data = data, parts_formatted = parts_formatted,

return table.concat(text_sections)

end

part.ts = export.make_affix(part.ts, part.lang, Latn, affix_type)

end

local function insert_affix_category(categories, pos, affix_type, part, sort_key, sort_base)

-- Don't add a '*fixed with' category if the link term is empty or is in a different language.

if part.term and not part.part_lang then

(part.id and " (" .. part.id .. ")" or "")

if sort_key or sort_base then

make_part_into_affix(data.prefix, data.lang, data.sc, "prefix")

make_part_into_affix(data.suffix, data.lang, data.sc, "suffix")

-- Create circumfix term.

local sort_base

if data.base.term then

end

-- Insert the categories, but don't add a '*fixed with' category if the link term is in a different language.

if not data.prefix.part_lang then

circumfix), sort_key=data.sort_key, sort_base=sort_base})

end

make_part_into_affix(data.prefix, data.lang, data.sc, "prefix")

make_part_into_affix(data.suffix, data.lang, data.sc, "suffix")

-- Make links out of all the parts.

local prefix_sort_base

if data.base and data.base.term then

elseif data.suffix.term then

end

-- Hyphenate the affixes and apply any affix mappings.

make_part_into_affix(data.infix, data.lang, data.sc, "infix")

-- Make links out of all the parts.

make_part_into_affix(prefix, data.lang, data.sc, "prefix")

end

-- Make links out of all the parts.

first_sort_base = ine(data.prefixes[2].term) or ine(data.prefixes[2].alt)

if first_sort_base then

end

elseif data.base then

first_sort_base = ine(data.base.term) or ine(data.base.alt)

if first_sort_base then

end

end

for i, suffix in ipairs(data.suffixes) do

make_part_into_affix(suffix, data.lang, data.sc, "suffix")

end