Module:bg-nominal

The following documentation is located at Module:bg-nominal/documentation.
Useful links: subpage list • links • transclusions • testcases • sandbox
	This module needs documentation.
	Please document this module by describing its purpose and usage on the documentation page.
local export = {}


--[=[

Authorship: Ben Wing <benwing2>

]=]

--[=[

TERMINOLOGY:

-- "slot" = A particular case/number/definiteness (and gender for adjectives) combination.
	 Example slot names for nouns are "ind_pl" (indefinite plural), "def_obj_sg" (definite objective
	 singular), "voc_sg" (vocative singular). Example slot names for adjectives are "ind_pl"
	 (indefinite plural) and "def_obj_m_sg" (definite object masculine singular) Each slot is filled
	 with zero or more forms.

-- "form" = The declined Bulgarian form representing the value of a given slot. For example, мо́мко
	 is a form, representing the value of the voc_sg slot of the lemma мо́мък "youth".

-- "lemma" = The dictionary form of a given Bulgarian term. Generally the indefinite (masculine)
	 singular, but will be the indefinite plural of plurale tantum nouns (e.g. га́щи "pants"), and
	 may occasionally be another form if the indefinite (masculine) singular is missing.

-- "plurale tantum" (plural "pluralia tantum") = A noun that exists only in the plural. Examples are
	 очила́ "glasses" and три́ци "bran".

-- "singulare tantum" (plural "singularia tantum") = A noun that exists only in the singular.
	Examples are ори́з "rice" and Бълга́рия "Bulgaria".
]=]

local lang = require("Module:languages").getByCode("bg")
local m_table = require("Module:table")
local m_links = require("Module:links")
local m_string_utilities = require("Module:string utilities")
local iut = require("Module:inflection utilities")
local m_para = require("Module:parameters")
local com = require("Module:bg-common")

local current_title = mw.title.getCurrentTitle()
local NAMESPACE = current_title.nsText
local PAGENAME = current_title.text

local u = require("Module:string/char")
local rsplit = mw.text.split
local rfind = mw.ustring.find
local rmatch = mw.ustring.match
local rgmatch = mw.ustring.gmatch
local rsubn = mw.ustring.gsub
local ulen = mw.ustring.len
local uupper = mw.ustring.upper

local AC = u(0x0301) -- acute =  ́

-- version of rsubn() that discards all but the first return value
local function rsub(term, foo, bar)
	local retval = rsubn(term, foo, bar)
	return retval
end

-- version of rsubn() that returns a 2nd argument boolean indicating whether
-- a substitution was made.
local function rsubb(term, foo, bar)
    local retval, nsubs = rsubn(term, foo, bar)
    return retval, nsubs > 0
end

local noun_overriding_forms = {
	 = true,
	 = true,
	 = true,
	 = true,
	 = true,
	 = true,
	 = true,
	 = true,
	 = true,
	 = true,
	 = true,
	 = true,
	 = true,
	 = true,
	 = true,
	 = true,
}


local boolean_noun_overriding_props = {
	 = true,
	 = true,
	 = true,
	 = true,
}


local boolean_adj_overriding_props = {
	 = true,
	 = true,
	 = true,
	 = true,
}


local noun_slots = {
	 = "indef|s",
	 = "def|sbj|s",
	 = "def|obj|s",
	 = "voc|s",
	 = "acc|s",
	 = "gen|s",
	 = "dat|s",
	 = "voc|p",
	 = "acc|p",
	 = "gen|p",
	 = "dat|p",
	 = "indef|p",
	 = "def|p",
	 = "count|form",
}

local extra_noun_cases = {"acc", "gen", "dat"}

local adj_slots = {
	 = "indef|m|s",
	 = "def|sbj|m|s",
	 = "def|obj|m|s",
	 = "indef|f|s",
	 = "def|f|s",
	 = "indef|n|s",
	 = "def|n|s",
	 = "indef|p",
	 = "def|p",
	 = "voc|m|s",
	-- Extra slot for possessive forms.
	 = "short|form",
	-- Extra slots for два and related words.
	 = "indef|m|p",
	 = "def|m|p",
	 = "indef|f|p|;|indef|n|p",
	 = "def|f|p|;|def|n|p",
	-- Extra slot for demonstrative and interrogative pronouns.
	 = "m|s",
	 = "nom|m|s",
	 = "acc|m|s",
	 = "dat|m|s",
	 = "f|s",
	 = "n|s",
	 = "p",
}

local masc_adj_to_noun_slots = {
	 = {"ind_sg", "acc_sg", "gen_sg", "dat_sg"},
	 = "def_sub_sg",
	 = "def_obj_sg",
	 = "voc_sg",
}

local fem_adj_to_noun_slots = {
	 = {"ind_sg", "voc_sg", "acc_sg", "gen_sg", "dat_sg"},
	 = {"def_sub_sg", "def_obj_sg"},
}

local neut_adj_to_noun_slots = {
	 = {"ind_sg", "voc_sg", "acc_sg", "gen_sg", "dat_sg"},
	 = {"def_sub_sg", "def_obj_sg"},
}

local pl_adj_to_noun_slots = {
	 = {"ind_pl", "count", "voc_pl", "acc_pl", "gen_pl", "dat_pl"},
	 = "def_pl",
}

local potential_noun_lemma_slots = {
	"ind_sg",
	"ind_pl"
}

local potential_adj_lemma_slots = {
	"ind_m_sg",
	"ind_pl"
}


-- Add a tracking category to the page.
local function track(page)
	require("Module:debug").track("bg-nominal/" .. page)
	return true
end


-- Given an alternating run of the format returned by `parse_balanced_segment_run`,
-- where the even-numbered segments are footnotes and the whole run describes an adjective
-- accent spec (e.g. "b*(я)" split as {"b*(я)"}), parse the accent spec and return an object
-- describing this spec. No footnotes are currently allowed in the accent spec and hence an
-- error will be thrown if there are any even-numbered segments. The returned object is e.g.
-- (for the above spec)
--
-- {
--   accents = {"b"},
--   reducible = true,
--   ya = true,
-- }
--
-- Other possible fields of the object:
--
-- soft_sign = BOOLEAN
-- nocomp = BOOLEAN
-- ch = BOOLEAN
-- che = BOOLEAN
-- ur = BOOLEAN
local function parse_adj_accent_spec(accent_run)
	if #accent_run ~= 1 then
		error("Bracketed footnotes not allowed in adjective accent specs: '" .. table.concat(accent_run) .. "'")
	end
	local retval = {accents = {}}
	local accents, rest = accent_run:match("^(*)(.-)$")
	for accent in accents:gmatch(".") do
		table.insert(retval.accents, accent)
	end
	rest, retval.reducible = rsubb(rest, "%*", "")
	rest, retval.nocomp = rsubb(rest, "!", "")
	rest, retval.soft_sign = rsubb(rest, "%(ь%)", "")
	rest, retval.ch = rsubb(rest, "%(ч%)", "")
	rest, retval.che = rsubb(rest, "%(че%)", "")
	rest, retval.ur = rsubb(rest, "%(ър%)", "")
	rest, retval.ya = rsubb(rest, "%(я%)", "")
	if rest ~= "" then
		error("Unrecognized indicator: '" .. rest .. "'")
	end
	return retval
end


-- Given an alternating run of the format returned by `parse_balanced_segment_run`,
-- where the even-numbered segments are footnotes and the whole run describes
-- a noun accent spec (e.g. "ad(v)+ове++и" split as {"ad(v)+ове++и", "", ""}),
-- parse the accent spec and return an object describing this spec. The returned
-- object is e.g. (for the above spec)
--
-- {
--   accents = {"a", "d"},
--   plurals = {{plural = "ове"}, {plural = "и", double_plus = true, footnotes = {""}}},
--   vocative = true,
-- }
--
-- Other possible fields of the object:
--
-- gender = STRING (either "m", "f" or "n")
-- reducible = BOOLEAN
-- reducible_vocative = BOOLEAN
-- reducible_count = BOOLEAN
-- reducible_definite = BOOLEAN
-- human = BOOLEAN
-- soft_sign = BOOLEAN
-- no_sign_sign = BOOLEAN
-- remove_in = BOOLEAN
-- ur = BOOLEAN
local function parse_noun_accent_spec(accent_run)
	local retval = {accents = {}, plurals = {}}
	local plurals = {}
	local plural_groups = iut.split_alternating_runs(accent_run, "%+")
	local double_plus = false
	for i, plural_group in ipairs(plural_groups) do
		if i > 1 and retval.is_adj then
			error("Explicit plurals not allowed with adjectival forms: '" .. table.concat(accent_run) .. "'")
		elseif i > 1 then
			if #plural_group == 1 and plural_group == "" then
				if double_plus then
					error("Too many plus signs: '" .. table.concat(accent_run) .. "'")
				else
					double_plus = true
				end
			else
				local plural = {plural = plural_group, double_plus = double_plus}
				double_plus = false
				for j = 2, #plural_group - 1, 2 do
					if plural_group ~= "" then
						error("Extraneous text after bracketed footnotes: '" .. table.concat(plural_group) .. "'")
					end
					if not plural.footnotes then
						plural.footnotes = {}
					end
					table.insert(plural.footnotes, plural_group)
				end
				table.insert(retval.plurals, plural)
			end
		elseif #plural_group ~= 1 then
			error("Bracketed footnotes not allowed in accent specs: '" .. table.concat(plural_group) .. "'")
		else
			local rest
			rest, retval.is_adj = rsubb(plural_group, "#", "")
			if retval.is_adj then
				retval.nocomp = true
				rest, retval.has_vocative = rsubb(rest, "%(v%)", "")
				rest, retval.human = rsubb(rest, "%(h%)", "")
				local adj_accent_spec = parse_adj_accent_spec({rest})
				for prop, value in pairs(adj_accent_spec) do
					retval = value
				end
			else
				local accents
				local accents, rest = plural_group:match("^(*)(.-)$")
				for accent in accents:gmatch(".") do
					table.insert(retval.accents, accent)
				end
				rest, retval.reducible_vocative = rsubb(rest, "%(v%*%)", "")
				rest, retval.reducible_count = rsubb(rest, "%(c%*%)", "")
				rest, retval.reducible_definite = rsubb(rest, "%(d%*%)", "")
				rest, retval.reducible = rsubb(rest, "%*", "")
				rest, retval.has_vocative = rsubb(rest, "%(v%)", "")
				rest, retval.human = rsubb(rest, "%(h%)", "")
				rest, retval.soft_sign = rsubb(rest, "%(ь%)", "")
				rest, retval.no_soft_sign = rsubb(rest, "%(%-ь%)", "")
				if retval.soft_sign and retval.no_soft_sign then
					error("Conflicting specs: Can't specify both (ь) and (-ь)")
				end
				rest, retval.remove_in = rsubb(rest, "%(ин%)", "")
				rest, retval.ur = rsubb(rest, "%(ър%)", "")
				rest, retval.ya = rsubb(rest, "%(я%)", "")
				rest, retval.no_ya = rsubb(rest, "%(%-я%)", "")
				if retval.ya and retval.no_ya then
					error("Conflicting specs: Can't specify both (я) and (-я)")
				end
				local masc, fem, neut, g
				rest, masc = rsubb(rest, "%(m%)", "")
				if masc then
					g = "m"
				end
				rest, fem = rsubb(rest, "%(f%)", "")
				if fem then
					if g then
						error("Conflicting gender specs: Can't specify both (m) and (f)")
					end
					g = "f"
				end
				rest, neut = rsubb(rest, "%(n%)", "")
				if neut then
					if g then
						error("Conflicting gender specs: Can't specify both (" .. g .. ") and (n)")
					end
					g = "n"
				end
				retval.gender = g
				if rest ~= "" then
					error("Unrecognized indicator: '" .. rest .. "'")
				end
			end
		end
	end
	return retval
end


-- Given an alternating run of the format returned by `parse_balanced_segment_run`,
-- where the even-numbered segments are footnotes and the whole run describes
-- a form spec (e.g. "pl:+:мо́мце:момци́" split as
-- {"pl:+:мо́мце:момци́", "", "", "", ""}), parse the form spec and return
-- two values, e.g. (for the above spec)
--
-- "pl", {{value = "+"}, {value = "мо́мце"}, {value = "момци́", footnotes = {"", ""}}}
--
-- As special cases, if the form name is "n", the second value will be a string, one of
-- "sg", "pl" or "both", and if the form name is in `negative_*_overriding_forms`, the second value
-- will be `true`. Only the following form names are allowed:
--   * if from_noun, "n"
--   * if not is_adj, the keys in `noun_overriding_forms` and `boolean_noun_overriding_props`
--   * if is_adj and not from_noun, the keys in `boolean_adj_overriding_props`
--   * if is_adj and not from_noun, the keys in `adj_slots`
--   * if is_adj and from_noun, the keys in `noun_slots`
-- Note than `from_noun` should be true if the overall declension is of a noun
-- (including adjectival nouns) and `is_adj` should be true if the particular term we're
-- declining is an adjective or adjectival noun.
local function parse_form_spec(form_run, from_noun, is_adj)
	local colon_separated_groups = iut.split_alternating_runs(form_run, ":")
	local form_name_group = colon_separated_groups
	if #form_name_group ~= 1 then
		error("Bracketed footnotes not allowed after form name: '" .. table.concat(form_name_group) .. "'")
	end
	local form_name = form_name_group
	if from_noun and form_name == "n" then
		if #colon_separated_groups == 2 and #colon_separated_groups == 1 then
			local number = colon_separated_groups
			if number == "sg" or number == "pl" or number == "both" then
				return "n", number
			end
		end
		error("Number spec should be 'n:sg', 'n:pl' or 'n:both': '" .. table.concat(form_run))
	elseif (
		not is_adj and boolean_noun_overriding_props or
		is_adj and not from_noun and boolean_adj_overriding_props
	) then
		if #colon_separated_groups > 1 then
			error("Cannot specify a value for boolean spec '" .. form_name .. "'")
		end
		return form_name, true
	elseif (
		not is_adj and noun_overriding_forms or
		is_adj and not from_noun and adj_slots or
		is_adj and from_noun and noun_slots
	) then
		local forms = {}
		for i, colon_separated_group in ipairs(colon_separated_groups) do
			if i > 1 then
				local form = {value = colon_separated_group}
				for j = 2, #colon_separated_group - 1, 2 do
					if colon_separated_group ~= "" then
						error("Extraneous text after bracketed footnotes: '" .. table.concat(colon_separated_group) .. "'")
					end
					if not form.footnotes then
						form.footnotes = {}
					end
					table.insert(form.footnotes, colon_separated_group)
				end
				table.insert(forms, form)
			end
		end
		return form_name, forms
	else
		error("Unrecognized form name: '" .. form_name .. "'")
	end
end


-- Given an angle-bracket spec (the entire spec following a lemma, including the angle brackets),
-- parse the noun accent and form specs inside the angle brackets. The return value is a list of
-- accent-and-form specs, where each such spec is an object with a field 'accent_spec' in the
-- format returned by parse_noun_accent_spec(), plus zero or more fields describing forms, where the
-- field name is the form name and the value is the second return value of parse_form_spec().
-- For example, given "<a*+ове+а,/pl:момци́>", the return value will be
-- 
-- {
--   {
--     accent_spec = {
--       accents = {"a"},
--       reducible = true,
--       plurals = {{plural = "ове"}, {plural = "а", footnotes = {""}}},
--     }
--   },
--   {
--     accent_spec = {
--       accents = {},
--       plurals = {},
--     },
--     pl = {{value = "момци́", footnotes = {"", ""}}},
--   },
-- }
local function parse_noun_accent_and_form_specs(angle_bracket_spec)
	local inside = rmatch(angle_bracket_spec, "^<(.*)>$")
	assert(inside)
	local bracketed_runs = iut.parse_balanced_segment_run(inside, "")
	local comma_separated_groups = iut.split_alternating_runs(bracketed_runs, ",")
	local accent_and_form_specs = {}
	for _, comma_separated_group in ipairs(comma_separated_groups) do
		local accent_and_form_spec = {}
		local slash_separated_groups = iut.split_alternating_runs(comma_separated_group, "/")
		accent_and_form_spec.accent_spec = parse_noun_accent_spec(slash_separated_groups)
		for i, slash_separated_group in ipairs(slash_separated_groups) do
			if i > 1 then
				local form_name, forms = parse_form_spec(slash_separated_group,
					"from noun", accent_and_form_spec.accent_spec.is_adj)
				if accent_and_form_spec then
					error("Cannot specify '" .. form_name .. "' twice")
				end
				accent_and_form_spec = forms
			end
		end
		if accent_and_form_spec and accent_and_form_spec then
			error("Can't specify both 'count' and '-count'")
		end
		if accent_and_form_spec and accent_and_form_spec then
			error("Can't specify both 'def' and '-def'")
		end
		table.insert(accent_and_form_specs, accent_and_form_spec)
	end
	return accent_and_form_specs
end


-- Given an angle-bracket spec (the entire spec following a lemma, including the angle brackets),
-- parse the adjective accent and form specs inside the angle brackets. The return value is a list of
-- accent-and-form specs, where each such spec is an object with a field 'accent_spec' in the
-- format returned by parse_noun_accent_spec(). Currently there are no other fields describing forms;
-- that may change.
--
-- For example, given "<a*,b/def_f_sg:мо́ята:мо́йта>", the return value will be
-- 
-- {
--   {
--     accent_spec = {
--       accents = {"a"},
--       reducible = true,
--     }
--   },
--   {
--     accent_spec = {
--       accents = {"b"},
--     },
--     def_f_sg = {{value = "мо́ята"}, {value = "мо́йта", footnotes = {""}}},
--   },
-- }
local function parse_adj_accent_and_form_specs(angle_bracket_spec)
	local inside = rmatch(angle_bracket_spec, "^<(.*)>$")
	assert(inside)
	local bracketed_runs = iut.parse_balanced_segment_run(inside, "")
	local comma_separated_groups = iut.split_alternating_runs(bracketed_runs, ",")
	local accent_and_form_specs = {}
	for _, comma_separated_group in ipairs(comma_separated_groups) do
		local accent_and_form_spec = {}
		local slash_separated_groups = iut.split_alternating_runs(comma_separated_group, "/")
		accent_and_form_spec.accent_spec = parse_adj_accent_spec(slash_separated_groups)
		for i, slash_separated_group in ipairs(slash_separated_groups) do
			if i > 1 then
				local form_name, forms = parse_form_spec(slash_separated_group, false, "is adj")
				if accent_and_form_spec then
					error("Cannot specify '" .. form_name .. "' twice")
				end
				accent_and_form_spec = forms
			end
		end
		table.insert(accent_and_form_specs, accent_and_form_spec)
	end
	return accent_and_form_specs
end


-- Parse a multiword spec such as "]<#> ]<>".
-- The return value is a table of the form
-- {
--   word_specs = {WORD_SPEC, WORD_SPEC, ...},
--   post_text = "TEXT-AT-END",
-- }
--
-- where WORD_SPEC describes an individual declined word and "TEXT-AT-END" is any raw text that
-- may occur after all declined words. Each WORD_SPEC is of the form
--
-- {
--   lemma = "LEMMA",
--   accent_and_form_specs = {ACCENT_AND_FORM_SPEC, ACCENT_AND_FORM_SPEC, ...}
--   before_text = "TEXT-BEFORE-WORD",
--   forms = {},
-- }
--
-- For example, the return value for "]<#> ]<>" is
-- {
--   word_specs = {
--     {
--       lemma = "]",
--       accent_and_form_specs = {
--         {
--           accent_spec = {
--             is_adj = true,
--           }
--         },
--       }
--       before_text = "",
--       forms = {},
--     },
--     {
--       lemma = "]",
--       accent_and_form_specs = {
--         {
--           accent_spec = {
--           }
--         },
--       }
--       before_text = " ",
--       forms = {},
--     },
--   },
--   post_text = "",
-- }
local function parse_multiword_spec(segments, is_adj)
	local multiword_spec = {
		word_specs = {}
	}
	for i = 2, #segments - 1, 2 do
		local word_spec = {}
		local bracketed_runs = iut.parse_balanced_segment_run(segments, "")
		local space_separated_groups = iut.split_alternating_runs(bracketed_runs, "", "preserve splitchar")
		local before_text = {}
		for j, space_separated_group in ipairs(space_separated_groups) do
			if j == #space_separated_groups then
				word_spec.lemma = m_links.remove_links(table.concat(space_separated_group))
				if word_spec.lemma == "" then
					error("Word is blank: '" .. table.concat(segments) .. "'")
				end
			else
				table.insert(before_text, table.concat(space_separated_group))
			end
		end
		word_spec.before_text = m_links.remove_links(table.concat(before_text))
		word_spec.accent_and_form_specs = is_adj and parse_adj_accent_and_form_specs(segments) or
			parse_noun_accent_and_form_specs(segments)
		word_spec.forms = {}
		table.insert(multiword_spec.word_specs, word_spec)
	end
	multiword_spec.post_text = m_links.remove_links(segments)
	return multiword_spec
end


-- Parse an alternant, e.g. "((мо́лив<>,моли́в<>))". The return value is a table of the form
-- {
--   alternants = {MULTIWORD_SPEC, MULTIWORD_SPEC, ...}
-- }
--
-- where MULTIWORD_SPEC describes a given alternant and is as returned by parse_multiword_spec().
local function parse_alternant(alternant, is_adj)
	local parsed_alternants = {}
	local alternant_text = rmatch(alternant, "^%(%((.*)%)%)$")
	local segments = iut.parse_balanced_segment_run(alternant_text, "<", ">")
	local comma_separated_groups = iut.split_alternating_runs(segments, ",")
	local alternant_spec = {alternants = {}}
	for _, comma_separated_group in ipairs(comma_separated_groups) do
		table.insert(alternant_spec.alternants, parse_multiword_spec(comma_separated_group, is_adj))
end
	return alternant_spec
end


-- Top-level parsing function. Parse a multiword spec that may have alternants in it.
-- The return value is a table of the form
-- {
--   alternant_or_word_specs = {ALTERNANT_OR_WORD_SPEC, ALTERNANT_OR_WORD_SPEC, ...}
--   post_text = "TEXT-AT-END",
-- }
--
-- where ALTERNANT_OR_WORD_SPEC is either an alternant spec as returned by parse_alternant()
-- or a word spec as described in the comment above parse_multiword_spec(). An alternant spec
-- looks as follows:
-- {
--   alternants = {MULTIWORD_SPEC, MULTIWORD_SPEC, ...},
--   before_text = "TEXT-BEFORE-ALTERNANT",
-- }
-- i.e. it is like what is returned by parse_alternant() but has an extra `before_text` field.
local function parse_alternant_multiword_spec(text, is_adj)
	local alternant_multiword_spec = {alternant_or_word_specs = {}}
	local alternant_segments = m_string_utilities.capturing_split(text, "(%(%(.-%)%))")
	local last_post_text
	for i = 1, #alternant_segments do
		if i % 2 == 1 then
			local segments = iut.parse_balanced_segment_run(alternant_segments, "<", ">")
			local multiword_spec = parse_multiword_spec(segments, is_adj)
			for _, word_spec in ipairs(multiword_spec.word_specs) do
				table.insert(alternant_multiword_spec.alternant_or_word_specs, word_spec)
			end
			last_post_text = multiword_spec.post_text
		else
			local alternant_spec = parse_alternant(alternant_segments, is_adj)
			alternant_spec.before_text = last_post_text
			table.insert(alternant_multiword_spec.alternant_or_word_specs, alternant_spec)
		end
	end
	alternant_multiword_spec.post_text = last_post_text
	return alternant_multiword_spec
end


local function map_word_specs(alternant_multiword_spec, fun)
	for _, alternant_or_word_spec in ipairs(alternant_multiword_spec.alternant_or_word_specs) do
		if alternant_or_word_spec.alternants then
			for _, multiword_spec in ipairs(alternant_or_word_spec.alternants) do
				for _, word_spec in ipairs(multiword_spec.word_specs) do
					fun(word_spec)
				end
			end
		else
			fun(alternant_or_word_spec)
		end
	end
end


-- Check that multisyllabic lemmas have stress, and add stress to monosyllabic
-- lemmas if needed.
local function check_lemma_stress(alternant_multiword_spec)
	map_word_specs(alternant_multiword_spec, function(word_spec)
		word_spec.lemma = com.add_monosyllabic_stress(word_spec.lemma)
		if not rfind(word_spec.lemma, AC) then
			error("Multisyllabic lemma '" .. word_spec.lemma .. "' needs an accent")
		end
	end)
end


-- Construct the "reduced" version of a stem. This removes an е or ъ followed by a word-final
-- consonant, stresses the final syllable of the result if necessary, and converts бое́ц into бо́йц- and бо́як into бо́йк-.
-- An error is thrown if the stem can't be reduced.
local function reduce_stem(stem)
	local vowel_ending_stem, final_cons = rmatch(stem, "^(.*" .. com.vowel_c .. AC .. "?)́?(" .. com.cons_c .. ")$")
	if vowel_ending_stem then
		-- бое́ц etc.
		return com.maybe_stress_final_syllable(vowel_ending_stem .. "й" .. final_cons)
	end
	local initial_stem, final_cons = rmatch(stem, "^(.*)́?(" .. com.cons_c .. ")$")
	if initial_stem then
		return com.maybe_stress_final_syllable(initial_stem .. final_cons)
	end
	error("Unable to reduce stem: '" .. stem .. "'")
end


-- Return the stem of a given noun. This removes any endings -а/-я/-е/-о/-й, and if
-- the result lacks an accent, it is added onto the last syllable.
local function get_noun_stem(lemma)
	local stem
	stem = rmatch(lemma, "^(.*)́?$")
	if stem then
		return com.maybe_stress_final_syllable(stem)
	end
	stem = rmatch(lemma, "^(%u.*)и́?$")
	if stem then
		-- proper names like До́бри
		return com.maybe_stress_final_syllable(stem)
	end
	stem = rmatch(lemma, "^(.*)й$")
	if stem then
		return stem
	end
	return lemma
end


-- Return the stem of a given adjective. This does the following:
-- (1) removes an ending -и, and if the result lacks an accent, it is added onto the last syllable;
-- (2) if (ър) was given, converts -ъ́р- to -ръ́- and vice-versa;
-- (3) if (я) was given, converts -е́- to -я́-;
-- (4) reduces the stem if appropriate.
local function get_adj_stem(lemma, accent_and_form_spec, as_noun)
	local accent_spec = accent_and_form_spec.accent_spec
	if as_noun and (accent_and_form_spec.n == "pl" or accent_spec.gender ~= "m") then
		-- If we're dealing with a feminine singular, neuter singular or plural adjectival noun form,
		-- we need to remove the ending to get the stem. No need to do any further frobbing, as the
		-- resulting stem will be used for all forms.
		local stem = rsub(lemma, "́?$", "")
		return com.maybe_stress_final_syllable(stem)
	end
	local stem = rmatch(lemma, "^(.*)и́?$")
	if stem then
		stem = com.maybe_stress_final_syllable(stem)
	else
		stem = rmatch(lemma, "^(.*)й$") or lemma
	end
	if accent_spec.ur then
		if rfind(stem, "ъ́р") then
			stem = rsub(stem, "ъ́р", "ръ́")
		elseif rfind(stem, "ръ́") then
			stem = rsub(stem, "ръ́", "ъ́р")
		else
			error("Indicator (ър) specified but stem doesn't contain -ъ́р- or -ръ́-")
		end
	elseif accent_spec.ya then
		if rfind(stem, "е́") then
			stem = rsub(stem, "е́", "я́")
		elseif not rfind(stem, "я́") then
			error("Indicator (я) specified but stem doesn't contain -я́- or -е́-")
		end
	end
	if accent_spec.reducible then
		return reduce_stem(stem)
	else
		return stem
	end
end


-- Construct all the stems needed for declining an adjective. This does the following:
-- (1) adds stress to a monosyllabic lemma if needed;
-- (2) throws an error if a multisyllabic lemma is given without any stress;
-- (3) constructs the stem of each accent_spec using get_adj_stem().
local function construct_adj_stems(alternant_multiword_spec)
	map_word_specs(alternant_multiword_spec, function(word_spec)
		for _, accent_and_form_spec in ipairs(word_spec.accent_and_form_specs) do
			local accent_spec = accent_and_form_spec.accent_spec
			accent_spec.stem = get_adj_stem(word_spec.lemma, accent_and_form_spec)
		end
	end)
end


-- Construct all the stems needed for declining a noun. This does the following:
-- (1) constructs the stem using get_noun_stem();
-- (2) constructs the reduced stem using reduce_stem(), if needed.
-- We don't construct the reduced stem unless the user gave a reduction spec somewhere;
-- otherwise we'll get an error on non-reducible stems.
local function construct_noun_stems(alternant_multiword_spec)
	map_word_specs(alternant_multiword_spec, function(word_spec)
		word_spec.stem = get_noun_stem(word_spec.lemma)
		local needs_reduced_stem = false
		for _, accent_and_form_spec in ipairs(word_spec.accent_and_form_specs) do
			local accent_spec = accent_and_form_spec.accent_spec
			if accent_spec.is_adj then
				accent_spec.stem = get_adj_stem(word_spec.lemma, accent_and_form_spec, "as noun")
			elseif accent_spec.reducible or accent_spec.reducible_definite or accent_spec.reducible_count or
				accent_spec.reducible_vocative then
				needs_reduced_stem = true
				break
			end
		end
		if needs_reduced_stem then
			word_spec.reduced_stem = reduce_stem(word_spec.stem)
		end
	end)
end


-- Concatenate a stem and an ending. If the ending has an accent, any accent on the stem is removed.
-- If UR is specified, convert the sequence CръC to CърC, preserving any accent on -ъ-.
local function combine_stem_and_ending(stem, ending, accent_spec, is_adj)
	if not is_adj and accent_spec.ur and rfind(ending, "^" .. com.vowel_c) then
		stem = rsub(stem, "(" .. com.cons_c .. ")ръ(" .. AC .. "?)(" .. com.cons_c .. ")", "%1ъ%2р%3")
	end
	if not accent_spec.no_ya and (rfind(ending, AC) or (accent_spec.ya and rfind(ending, "^"))) then
		stem = rsub(stem, "я́", "е́")
	end
	if rfind(ending, AC) then
		stem = rsub(stem, AC, "")
	end
	return stem .. ending
end


-- Given an adjective and an accent-and-form spec (an element of the list returned by parse_accent_and_form_specs()),
-- do any autodetection of gender, accent and indicators. This modifies the accent-and-form spec in place.
local function detect_adj_accent_and_form_spec(lemma, accent_and_form_spec)
	local accent_spec = accent_and_form_spec.accent_spec
	-- Detect accent if not specified.
	if #accent_spec.accents == 0 then
		local accent
		if rfind(lemma, "и́$") then
			accent = "b"
		elseif accent_spec.reducible and rfind(lemma, "́" .. com.cons_c .. "$") then
			-- Reducible adjective and accent on reducible vowel, e.g. добъ́р -> fem добра́
			accent = "b"
		else
			accent = "a"
		end
		table.insert(accent_spec.accents, accent)
	end
	-- Detect soft-sign indicator.
	local accent_spec = accent_and_form_spec.accent_spec
	if rfind(lemma, "и́?$") and accent_spec.soft_sign then
		accent_spec.soft_sign_i = true
	end
	if rfind(lemma, "й$") then
		-- мой, твой, etc.
		accent_spec.soft_sign = true
		accent_spec.soft_sign_i = true
	end
end


-- Given a noun and an accent-and-form spec (an element of the list returned by parse_accent_and_form_specs()),
-- do any autodetection of gender, accent and indicators. This modifies the accent-and-form spec in place.
local function detect_noun_accent_and_form_spec(lemma, accent_and_form_spec)
	local accent_spec = accent_and_form_spec.accent_spec
	if accent_spec.is_adj then
		-- Detect gender if not specified.
		if rfind(lemma, "́?$") then
			g = "f"
		elseif rfind(lemma, "́?$") then
			g = "n"
		else
			g = "m"
		end
		accent_spec.gender = g

		-- Detect has-vocative indicator.
		if accent_spec.human or accent_and_form_spec.voc_sg or accent_and_form_spec.voc_pl then
			accent_spec.has_vocative = true
		end
		-- Detect has-count indicator.
		if accent_and_form_spec.count then
			accent_spec.has_count = true
		end
		detect_adj_accent_and_form_spec(lemma, accent_and_form_spec)
	else
		-- Detect gender if not specified.
		local g = accent_spec.gender
		if not g then
			if rfind(lemma, "́?$") then
				g = "f"
			elseif rfind(lemma, com.vowel_c .. "*о́?ст$") then
				-- If the lemma ends in -ост and there is a preceding vowel, then this is the feminine abstract noun suffix -ост
				g = "f"
			elseif rfind(lemma, "^%u.*и́?$") then
				-- proper names like До́бри
				g = "m"
			elseif rfind(lemma, "́?$") then
				g = "n"
			else
				g = "m"
			end
			accent_spec.gender = g
			
		end
		-- Detect accent if not specified.
		if #accent_spec.accents == 0 then
			local accent
			if g == "f" and rfind(lemma, com.cons_c .. "$") then
				accent = "d"
			elseif accent_spec.reducible and rfind(lemma, "́" .. com.cons_c .. "$") then
				-- Reducible noun and accent on reducible vowel, e.g. чуждене́ц -> чужденци́
				accent = "c"
			elseif rfind(lemma, "́$") then
				accent = "c"
			else
				accent = "a"
			end
			table.insert(accent_spec.accents, accent)
		end
		-- Detect soft-sign indicator.
		if g == "m" and not accent_spec.no_soft_sign and (
			rfind(lemma, "й$") or rfind(lemma, com.vowel_c .. AC .. "?тел$") or rfind(lemma, com.vowel_c .. AC .. "?" .. com.cons_c .. "+а́?р$")
		) then
			accent_spec.soft_sign = true
		end
		-- Detect plural if not specified.
		if #accent_spec.plurals == 0 then
			local plural
			if g == "f" then
				plural = "и"
			elseif g == "m" then
				if rfind(lemma, "^%u") then
					if rfind(lemma, "́?$") then
						-- До́бри, Или́я, Благо́й
						plural = "евци"
					elseif rfind(lemma, "́?в$") then
						-- Ива́нов/Ивано́в, Пе́нчев
						plural = {"и", "ци"}
					else
						-- Пе́тър, Ива́н, Кру́м, Нико́ла
						plural = "овци"
					end
				elseif rfind(lemma, "о́?$") then
					-- дя́до, гле́зльо
					plural = "овци"
				elseif rfind(lemma, "е́?$") then
					-- аташе́
					plural = "ета"
				elseif not com.is_monosyllabic(lemma) then
					-- ези́к, друга́р, геро́й, etc.; баща́, коле́га
					plural = "и"
				elseif rfind(lemma, "й$") then
					-- край, брой
					plural = "еве"
				elseif accent_spec.soft_sign then
					-- кон, зет, цар
					plural = "ьове"
				else
					plural = "ове"
				end
			elseif rfind(lemma, "о́?$") or rfind(lemma, "е́?$") then
				plural = "а"
			elseif rfind(lemma, "и́?е$") then
				plural = "я"
			elseif rfind(lemma, "ане$") then
				-- ди́шане, схва́щане, пъту́ване, присти́гане, etc.
				plural = "ия"
			elseif rfind(lemma, "е́?$") then
				plural = "ета"
			else
				plural = "та"
			end
			if type(plural) == "table" then
				for _, p in ipairs(plural) do
					table.insert(accent_spec.plurals, {plural=p})
				end
			else
				table.insert(accent_spec.plurals, {plural=plural})
			end
		end
		-- Detect has-vocative indicator.
		if accent_and_form_spec.voc then
			-- If explicit override for vocative, we have a vocative regardless.
			accent_spec.has_vocative = true
		elseif accent_spec.gender == "n" then
			-- Otherwise if neuter, no vocative even if (v) or (h) is used.
			accent_spec.has_vocative = false
		elseif accent_spec.gender == "f" and rfind(lemma, com.cons_c .. "$") then
			-- Otherwise if feminine and ending in a consonant, no vocative even if (v) or (h) is used.
			accent_spec.has_vocative = false
		elseif accent_spec.reducible_vocative or accent_spec.human then
			-- Otherwise, respect (v*) and (h). Note that (v) already sets has_vocative = true.
			accent_spec.has_vocative = true
		end
		-- Detect reducible indicators.
		if g == "m" and rfind(lemma, com.vowel_c .. AC .. "?зъм$") then
			accent_spec.reducible = true
			accent_spec.reducible_definite = true
			if accent_spec.has_vocative then
				accent_spec.reducible_vocative = true
			end
		end
		-- Detect no-def-sg indicator.
		if rfind(lemma, "^%u") and not accent_and_form_spec.def then
			accent_and_form_spec = true
		end
		-- Detect no-count indicator.
		if accent_spec.human and not accent_and_form_spec.count then
			accent_and_form_spec = true
		end
		-- Detect has-count indicator.
		-- (1) Yes if an explicit count override is given.
		accent_spec.has_count = accent_and_form_spec.count or (
			-- Otherwise:
			-- (2) No if -count is explicitly given.
			not accent_and_form_spec and
			-- (3) Only masculine nouns ending in a consonant normally have a count form.
			accent_spec.gender == "m" and
			rfind(lemma, com.cons_c .. "$")
		)
	end
end


-- Call detect_adj_accent_and_form_spec() on all accent-and-form specs in ALTERNANT_MULTIWORD_SPEC.
local function detect_all_adj_accent_and_form_specs(alternant_multiword_spec)
	map_word_specs(alternant_multiword_spec, function(word_spec)
		for _, accent_and_form_spec in ipairs(word_spec.accent_and_form_specs) do
			detect_adj_accent_and_form_spec(word_spec.lemma, accent_and_form_spec)
		end
	end)
end


-- Call detect_noun_accent_and_form_spec() on all accent-and-form specs in ALTERNANT_MULTIWORD_SPEC.
local function detect_all_noun_accent_and_form_specs(alternant_multiword_spec)
	map_word_specs(alternant_multiword_spec, function(word_spec)
		for _, accent_and_form_spec in ipairs(word_spec.accent_and_form_specs) do
			detect_noun_accent_and_form_spec(word_spec.lemma, accent_and_form_spec)
		end
	end)
end


local function init_active_adj_slots()
	local active_slots = {}
	return active_slots
end


local function set_active_adj_slots(active_slots, accent_and_form_spec)
	if accent_and_form_spec.koj then
		active_slots.nom_m_sg = true
		active_slots.acc_m_sg = true
		active_slots.dat_m_sg = true
		active_slots.f_sg = true
		active_slots.n_sg = true
		active_slots.pl = true
	elseif accent_and_form_spec.chij then
		active_slots.m_sg = true
		active_slots.f_sg = true
		active_slots.n_sg = true
		active_slots.pl = true
	elseif accent_and_form_spec.dva then
		active_slots.ind_m_pl = true
		active_slots.def_m_pl = true
		active_slots.ind_fn_pl = true
		active_slots.def_fn_pl = true
	else
		active_slots.ind_m_sg = true
		active_slots.def_sub_m_sg = true
		active_slots.def_obj_m_sg = true
		active_slots.ind_f_sg = true
		active_slots.def_f_sg = true
		active_slots.ind_n_sg = true
		active_slots.def_n_sg = true
		active_slots.ind_pl = true
		active_slots.def_pl = true
		if not accent_and_form_spec.accent_spec.nocomp then
			active_slots.comp = true
		end
	end
	if accent_and_form_spec then
		active_slots.add_voc = true
	end
	if accent_and_form_spec.short then
		active_slots.short = true
	end
end


-- Determine overall active adjective slots.
local function compute_overall_active_adj_slots(alternant_multiword_spec)
	local active_slots = init_active_adj_slots()
	map_word_specs(alternant_multiword_spec, function(word_spec)
		for _, accent_and_form_spec in ipairs(word_spec.accent_and_form_specs) do
			set_active_adj_slots(active_slots, accent_and_form_spec)
		end
	end)
	if active_slots.add_voc then
		active_slots.voc_m_sg = true
	end
	return active_slots
end


local function init_active_noun_slots()
	local active_slots = {}
	-- Set the always-active slots.
	active_slots.ind_sg = true
	return active_slots
end


local function set_active_noun_slots(active_slots, accent_and_form_spec)
	-- NOTE: We currently treat singular and plural as always active, and
	-- separately calculate the overall number, which is passed into places
	-- like make_noun_table() to determine which slots to actually use.

	-- The calculations to determine whether there's a vocative and/or a count
	-- form were done in detect_noun_accent_and_form_spec().
	if accent_and_form_spec.accent_spec.has_vocative then
		active_slots.voc_sg = true
		active_slots.voc_pl = true
	end
	if accent_and_form_spec.accent_spec.has_count then
		active_slots.count = true
	end
	for _, case in ipairs(extra_noun_cases) do
		-- Adjectival noun overrides currently use acc_sg, gen_sg, dat_sg,
		-- while regular noun overrides just use acc, gen, dat.
		if accent_and_form_spec or accent_and_form_spec then
			active_slots = true
		end
		if accent_and_form_spec then
			active_slots = true
		end
	end
	if accent_and_form_spec then
		active_slots.no_def = true
	end
	if accent_and_form_spec then
		active_slots.no_pl = true
	end
	if accent_and_form_spec then
		active_slots.no_def_pl = true
	end
	if accent_and_form_spec.n then
		if not active_slots.n then
			active_slots.n = accent_and_form_spec.n
		elseif active_slots.n ~= accent_and_form_spec.n then
			active_slots.n = "both"
		end
	end
end


local function convert_active_noun_slots_to_active_adj_slots(active_noun_slots)
	local active_adj_slots = init_active_adj_slots()
	if active_noun_slots.voc_sg then
		active_adj_slots.voc_m_sg = true
	end
	return active_adj_slots
end


-- Determine overall active noun slots.
local function compute_overall_active_noun_slots(alternant_multiword_spec)
	local active_slots = init_active_noun_slots()
	map_word_specs(alternant_multiword_spec, function(word_spec)
		for _, accent_and_form_spec in ipairs(word_spec.accent_and_form_specs) do
			set_active_noun_slots(active_slots, accent_and_form_spec)
		end
	end)
	if not active_slots.no_def then
		active_slots.def_sub_sg = true
		active_slots.def_obj_sg = true
	end
	if not active_slots.no_pl then
		active_slots.ind_pl = true
		if not active_slots.no_def_pl then
			active_slots.def_pl = true
		end
	end
	return active_slots
end


-- Construct the plural of the lemma specified in WORD_SPEC, given the accent spec
-- (as returned by parse_noun_accent_spec()), the plural ending (e.g. "ове"), and the accent indicator
-- (e.g. "a" or "d"). Return value is a string. This handles accenting the plural ending as necessary,
-- fetching the reduced stem if appropriate, removing final -ин if called for, and applying the
-- second palatalization if appropriate (e.g. ези́к -> ези́ци).
local function generate_noun_plural(word_spec, accent_spec, plural, accent)
	local ending = plural.plural
	if accent == "b" or accent == "c" then
		if accent == "b" and (ending == "ове" or ending == "ьове" or ending == "йове" or ending == "еве") or
			ending == "еса" or ending == "ена" then
			ending = ending .. AC
		else
			-- for any other plurals, put the stress on the first vowel if a stress isn't already present
			ending = com.maybe_stress_initial_syllable(ending)
		end
	end

	local stem = accent_spec.reducible and word_spec.reduced_stem or word_spec.stem
	
	if accent_spec.remove_in then
		local new_stem, removed = rsubb(stem, "и́?н$", "")
		if not removed then
			error("(ин) specified but stem '" .. stem .. "' doesn't end in -ин")
		end
		stem = com.maybe_stress_final_syllable(new_stem)
	end

	if not plural.double_plus and not rfind(word_spec.lemma, "нг$") and (
		-- ези́к -> ези́ци
		rfind(ending, "^и́?$") and rfind(word_spec.lemma, "$") or
		-- ръка́ -> ръце́
		rfind(ending, "^е́?$") and rfind(word_spec.lemma, "а́?$")
	) then
		local initial, last_cons = rmatch(stem, "^(.*)()$")
		if initial then
			return combine_stem_and_ending(initial .. com.second_palatalization, ending, accent_spec)
		end
	end

	return combine_stem_and_ending(stem, ending, accent_spec)
end


-- Construct the definite singular of the lemma specified in WORD_SPEC, given the accent spec
-- (as returned by parse_noun_accent_spec()) and the accent indicator (e.g. "a" or "d").
-- Return value is a string. This handles determining the appropriate ending (handling the
-- soft sign spec (ь) as needed), accenting the ending as necessary, and fetching the
-- reduced stem if appropriate.
local function generate_noun_definite_singular(word_spec, accent_spec, accent)
	local function stressed_ending()
		return accent == "b" or accent == "d"
	end
	if accent_spec.gender == "m" then
		if rfind(word_spec.lemma, "́?$") then
			return word_spec.lemma .. "та"
		elseif rfind(word_spec.lemma, "́?$") then
			return word_spec.lemma .. "то"
		else
			local ending
			if accent_spec.soft_sign then
				ending = stressed_ending() and "я́т" or "ят"
			elseif stressed_ending() then
				ending = "ъ́т"
			else
				ending = "ът"
			end
			local stem = accent_spec.reducible_definite and word_spec.reduced_stem or word_spec.stem
			return combine_stem_and_ending(stem, ending, accent_spec)
		end
	elseif accent_spec.gender == "f" then
		return combine_stem_and_ending(word_spec.lemma, stressed_ending() and "та́" or "та", accent_spec)
	else
		return combine_stem_and_ending(word_spec.lemma, "то", accent_spec)
	end
end
	

-- Construct the definite objective singular given the definite subjective singular form.
local function generate_noun_definite_objective_singular(def_sg)
	local stem, ending = rmatch(def_sg, "^(.*)(ъ́?т)$") 
	if stem then
		return stem .. (ending == "ъ́т" and "а́" or "а")
	end
	stem = rmatch(def_sg, "^(.*я́?)т$") 
	if stem then
		return stem
	end
	if rfind(def_sg, "т́?$") then
		return def_sg
	end
	error("Unrecognized ending for definite subjective singular: '" .. def_sg .. "'")
end


-- Construct the definite plural given the indefinite plural form.
local function generate_noun_definite_plural(plural_form)
	if rfind(plural_form, "́?$") then
		return plural_form .. "те"
	else
		return plural_form .. "та"
	end
end


-- Construct the count form of the lemma specified in WORD_SPEC, given the accent spec
-- (as returned by parse_noun_accent_spec()). Return value is a string, or nil if no count
-- form can be constructed (not a masculine lemma ending in a consonant). This handles
-- determining the appropriate ending (handling the soft sign spec (ь) as needed) and
-- fetching the reduced stem if appropriate.
local function generate_noun_count_form(word_spec, accent_spec)
	if accent_spec.gender ~= "m" or not rfind(word_spec.lemma, com.cons_c .. "$") then
		return nil
	end
	local stem = accent_spec.reducible_count and word_spec.reduced_stem or word_spec.stem
	if accent_spec.soft_sign then
		return combine_stem_and_ending(stem, "я", accent_spec)
	else
		return combine_stem_and_ending(stem, "а", accent_spec)
	end
end


-- Construct the vocative of the lemma specified in WORD_SPEC, given the accent spec
-- (as returned by parse_noun_accent_spec()). Return value is a string, or nil if no vocative
-- form can be constructed. This applies the rules described in ].
local function generate_noun_vocative(word_spec, accent_spec)
	if accent_spec.gender == "n" or not accent_spec.has_vocative then
		return nil
	end
	local lemma = word_spec.lemma
	if accent_spec.gender == "f" and rfind(lemma, com.cons_c .. "$") then
		return nil
	end
	local stem = accent_spec.reducible_vocative and word_spec.reduced_stem or word_spec.stem
	local ending
	if accent_spec.soft_sign then
		ending = "ю"
	elseif rfind(lemma, com.vowel_c .. AC .. "?я́?$") then
		ending = "йо"
	elseif rfind(lemma, "я́?$") then
		ending = "ьо"
	elseif rfind(lemma, "ца́?$") or rfind(lemma, "ка́?$") or rfind(lemma, "^%u.*ка́?$") then
		ending = "е"
	elseif rfind(lemma, "а́?$") or rfind(lemma, "$") or rfind(lemma, "и́?н$") then
		ending = "о"
	elseif rfind(lemma, "$") then
		return combine_stem_and_ending(rsub(stem, "$", "ж"), "е", accent_spec)
	else
		ending = "е"
	end
	return combine_stem_and_ending(stem, ending, accent_spec)
end


-- Construct the indefinite adjective forms.
local function generate_indefinite_adj_forms(formtable, accent_spec, accent, active_slots)
	local stem = accent_spec.stem
	local accent = accent == "b" and AC or ""
	iut.insert_form(formtable, "ind_f_sg",
		{form=combine_stem_and_ending(stem, (accent_spec.soft_sign and "я" or "а") .. accent, accent_spec, "is adj")})
	if accent_spec.ch then
		iut.insert_form(formtable, "ind_n_sg",
			{form=combine_stem_and_ending(stem, "е" .. accent, accent_spec, "is adj")})
		iut.insert_form(formtable, "ind_n_sg",
			{form=combine_stem_and_ending(stem, "о" .. accent, accent_spec, "is adj")})
	else
		iut.insert_form(formtable, "ind_n_sg",
			{form=combine_stem_and_ending(stem,
				((accent_spec.che or accent_spec.soft_sign_i) and "е" or accent_spec.soft_sign and "ьо" or "о") .. accent,
				accent_spec, "is adj")})
	end
	local ind_pl = combine_stem_and_ending(stem, "и" .. accent, accent_spec, "is adj")
	iut.insert_form(formtable, "ind_pl", {form=ind_pl})
	if active_slots.voc_m_sg then
		iut.insert_form(formtable, "voc_m_sg", {form=ind_pl})
		iut.insert_form(formtable, "voc_m_sg", {form=ind_pl .. "й", footnotes={""}})
	end
end


-- Construct the definite adjective forms based on the indefinite ones.
local function generate_definite_adj_forms(formtable, include_definite)
	if include_definite then
		iut.insert_forms(formtable, "def_sub_m_sg", iut.map_forms(formtable,
			function(form) return form .. "ят" end))
		iut.insert_forms(formtable, "def_obj_m_sg", iut.map_forms(formtable,
			function(form) return form .. "я" end))
		iut.insert_forms(formtable, "def_f_sg", iut.map_forms(formtable,
			function(form) return form .. "та" end))
		iut.insert_forms(formtable, "def_n_sg", iut.map_forms(formtable,
			function(form) return form .. "то" end))
		iut.insert_forms(formtable, "def_pl", iut.map_forms(formtable,
			function(form) return form .. "те" end))
	else
		iut.insert_forms(formtable, "def_sub_m_sg", formtable)
		iut.insert_forms(formtable, "def_obj_m_sg", formtable)
		iut.insert_forms(formtable, "def_f_sg", formtable)
		iut.insert_forms(formtable, "def_n_sg", formtable)
		iut.insert_forms(formtable, "def_pl", formtable)
	end
end


-- Handle a list of overriding forms (e.g. the forms specified by "/pl:мо́мце:момци́").
-- FORMS is the list of default forms generated according to the accent spec, and OVERRIDING_FORMS
-- is the list of overriding forms. Both of them are lists of objects of the form
-- {form=FORM, footnotes=FOOTNOTES}. Return the same sort of list. If there are no overriding
-- forms (OVERRIDING_FORMS is nil), the list in FORMS will be returned directly; otherwise a new
-- list of forms will be constructed from OVERRIDING_FORMS. If an element of OVERRIDING_FORMS has
-- the value "+", the forms in FORMS are inserted in its place. LEMMA and STEM are used in handling
-- forms in OVERRIDING_FORMS containing ~ or ~~ in them, replaced respectively lemma and stem.
-- FORMS may be a string such as "dat" or "gen", specifying the name of the overriding form. This
-- indicates that there are no default forms for this slot, and any use of "+" in OVERRIDING_FORMS
-- will cause an error (where the string is inserted into the error message).
local function handle_overriding_forms(lemma, stem, forms, overriding_forms)
	if not overriding_forms then
		if type(forms) == "table" then
			return forms
		else
			return nil
		end
	else
		local retforms = {}
		for _, overriding_spec in ipairs(overriding_forms) do
			local form = overriding_spec.value
			if form == "+" then
				if type(forms) == "string" then
					error("'/" .. forms .. "+' not supported, no default value")
				end
				for _, f in ipairs(forms) do
					iut.insert_form_into_list(retforms, {form=f.form, footnotes=overriding_spec.footnotes})
				end
			else
				form = rsub(form, "~~", stem)
				form = rsub(form, "~", lemma)
				iut.insert_form_into_list(retforms, {form=form, footnotes=overriding_spec.footnotes})
			end
		end
		return retforms
	end
end


-- Decline a single adjective term in WORD_SPEC (an object as returned by parse_simplified_specification())
-- corresponding to the accent-and-form spec in `accent_and_form_spec` (see parse_noun_accent_and_form_specs()).
-- This sets the form values in `WORD_SPEC.forms` (and `WORD_SPEC.compforms` and `WORD_SPEC.supforms`
-- if the adjective has comparative forms) for all slots. (If a given slot has no values,
-- it will not be present in `WORD_SPEC.forms`.) If `as_noun` is true, we're declining an adjectival noun
-- rather than an adjective as such.
local function decline_one_adj(word_spec, accent_and_form_spec, active_slots, active_noun_slots, include_definite)
	local accent_spec = accent_and_form_spec.accent_spec
	local lemma = word_spec.lemma
	local stem = accent_spec.stem
	local formtable = {[
		accent_and_form_spec.dva and "ind_m_pl" or
		accent_and_form_spec.koj and "nom_m_sg" or
		accent_and_form_spec.chij and "m_sg" or
		"ind_m_sg"
	] = {{form=lemma}}}
	for _, accent in ipairs(accent_spec.accents) do
		generate_indefinite_adj_forms(formtable, accent_spec, accent, active_slots)
	end
	generate_definite_adj_forms(formtable, include_definite)
	if active_noun_slots then
		local noun_formtable = {}
		local function copy_forms(forms_to_copy)
			for from_form, to_forms in pairs(forms_to_copy) do
				if type(to_forms) ~= "table" then
					to_forms = {to_forms}
				end
				for _, to_form in ipairs(to_forms) do
					if active_noun_slots then
						iut.insert_forms(noun_formtable, to_form, formtable)
					end
				end
			end
		end
		if active_noun_slots.n ~= "pl" then
			local forms_to_copy =
				accent_spec.gender == "m" and masc_adj_to_noun_slots or
				accent_spec.gender == "f" and fem_adj_to_noun_slots or
				neut_adj_to_noun_slots
			copy_forms(forms_to_copy)
		end
		if active_noun_slots.n ~= "sg" then
			copy_forms(pl_adj_to_noun_slots)
		end
		for slot, _ in pairs(noun_slots) do
			iut.insert_forms(word_spec.forms, slot, handle_overriding_forms(lemma, stem, noun_formtable,
				accent_and_form_spec))
		end
	else
		for slot, _ in pairs(adj_slots) do
			local forms = handle_overriding_forms(lemma, stem, formtable, accent_and_form_spec)
			iut.insert_forms(word_spec.forms, slot, forms)
			if active_slots.comp and not accent_spec.nocomp then
				if not word_spec.compforms then
					word_spec.compforms = {}
				end
				iut.insert_forms(word_spec.compforms, slot,
					iut.map_forms(forms, function(form) return "по́-" .. form end))
				if not word_spec.supforms then
					word_spec.supforms = {}
				end
				iut.insert_forms(word_spec.supforms, slot,
					iut.map_forms(forms, function(form) return "на́й-" .. form end))
			end
		end
	end
end


-- Decline the adjective in WORD_SPEC (an object as returned by parse_simplified_specification()).
-- This sets the form values in `WORD_SPEC.forms` (and `WORD_SPEC.compforms` and `WORD_SPEC.supforms`
-- if the adjective has comparative forms) for all slots. (If a given slot has no values,
-- it will not be present in `WORD_SPEC.forms`.)
local function decline_adj(word_spec, active_slots, include_definite)
	for _, accent_and_form_spec in ipairs(word_spec.accent_and_form_specs) do
		decline_one_adj(word_spec, accent_and_form_spec, active_slots, nil, include_definite)
	end
end


-- Decline a single noun term in WORD_SPEC (an object as returned by parse_simplified_specification())
-- corresponding to the accent-and-form spec in `accent_and_form_spec` (see parse_noun_accent_and_form_specs()).
-- This sets the form values in `WORD_SPEC.forms` for all slots. (If a given slot has no values,
-- it will not be present in `WORD_SPEC.forms`.)
local function decline_one_noun(word_spec, accent_and_form_spec, active_slots, include_definite)
	local lemma = word_spec.lemma
	local stem = word_spec.stem
	if active_slots.n == "pl" then
		for _, overriding_form in ipairs(noun_overriding_forms) do
			if not overriding_form:find("_pl$") and accent_and_form_spec then
				error("'/" .. overriding_form .. ":' not allowed for plurale tantum")
			end
		end

		-- Maybe set indefinite plural.
		local indefinite_plurals = {{form=lemma}}
		if active_slots.ind_pl then
			iut.insert_forms(word_spec.forms, "ind_pl",
				handle_overriding_forms(lemma, stem, indefinite_plurals, accent_and_form_spec.ind_pl))
		end

		-- Maybe set definite plural.
		if active_slots.def_pl then
			iut.insert_forms(word_spec.forms, "def_pl",
				handle_overriding_forms(lemma, stem,
					include_definite and iut.map_forms(indefinite_plurals, generate_noun_definite_plural) or indefinite_plurals,
					accent_and_form_spec.def_pl))
		end

		-- Maybe set "extra cases".
		for _, case in ipairs(extra_noun_cases) do
			local pl_slot = case .. "_pl"
			if active_slots then
				iut.insert_forms(word_spec.forms, pl_slot, handle_overriding_forms(lemma, stem, indefinite_plurals, accent_and_form_spec))
			end
		end
	else
		local accent_spec = accent_and_form_spec.accent_spec

		-- Always generate indefinite singulars since may be needed for the "extra cases" below.
		local indefinite_singulars = {{form = lemma}}

		-- Always generate indefinite plurals since may be needed for the "extra cases" below.
		local indefinite_plurals = {}
		for _, plspec in ipairs(accent_spec.plurals) do
			for _, accent in ipairs(accent_spec.accents) do
				iut.insert_form_into_list(indefinite_plurals,
					{form=generate_noun_plural(word_spec, accent_spec, plspec, accent), footnotes=plspec.footnotes}
				)
			end
		end
		indefinite_plurals = handle_overriding_forms(lemma, stem, indefinite_plurals, accent_and_form_spec.pl)

		-- Maybe set indefinite singular.
		if active_slots.ind_sg then
			iut.insert_forms(word_spec.forms, "ind_sg",
				handle_overriding_forms(lemma, stem, indefinite_singulars, accent_and_form_spec.ind))
		end

		-- Maybe set definite singular.
		if active_slots.def_sub_sg or active_slots.def_obj_sg then
			local definite_singulars
			if include_definite then
				definite_singulars = {}
				for _, accent in ipairs(accent_spec.accents) do
					iut.insert_form_into_list(definite_singulars,
						{form=generate_noun_definite_singular(word_spec, accent_spec, accent)}
					)
				end
			else
				definite_singulars = indefinite_singulars
			end
			definite_singulars = handle_overriding_forms(lemma, stem, definite_singulars, accent_and_form_spec.def)
			if active_slots.def_sub_sg then
				iut.insert_forms(word_spec.forms, "def_sub_sg",
					handle_overriding_forms(lemma, stem, definite_singulars, accent_and_form_spec.def_sub))
			end
			if active_slots.def_obj_sg then
				iut.insert_forms(word_spec.forms, "def_obj_sg",
					handle_overriding_forms(lemma, stem,
						include_definite and iut.map_forms(definite_singulars, generate_noun_definite_objective_singular) or
						definite_singulars,
						accent_and_form_spec.def_obj))
			end
		end

		-- Maybe set indefinite plural.
		if active_slots.ind_pl then
			iut.insert_forms(word_spec.forms, "ind_pl",
				handle_overriding_forms(lemma, stem, indefinite_plurals, accent_and_form_spec.ind_pl))
		end

		-- Maybe set definite plural.
		if active_slots.def_pl then
			iut.insert_forms(word_spec.forms, "def_pl",
				handle_overriding_forms(lemma, stem,
					include_definite and iut.map_forms(indefinite_plurals, generate_noun_definite_plural) or
					indefinite_plurals,
					accent_and_form_spec.def_pl))
		end

		-- Maybe set count.
		if active_slots.count then
			local count_forms = {}
			iut.insert_form_into_list(count_forms, {form=generate_noun_count_form(word_spec, accent_spec)})
			iut.insert_forms(word_spec.forms, "count", handle_overriding_forms(lemma, stem, count_forms, accent_and_form_spec.count))
		end

		-- Maybe set vocative singular.
		if active_slots.voc_sg then
			local vocatives = {}
			iut.insert_form_into_list(vocatives, {form=generate_noun_vocative(word_spec, accent_spec)})
			iut.insert_forms(word_spec.forms, "voc_sg", handle_overriding_forms(lemma, stem, vocatives, accent_and_form_spec.voc))
		end

		-- Maybe set vocative plural.
		if active_slots.voc_pl then
			iut.insert_forms(word_spec.forms, "voc_pl", handle_overriding_forms(lemma, stem, indefinite_plurals, accent_and_form_spec.voc_pl))
		end

		-- Maybe set "extra cases".
		for _, case in ipairs(extra_noun_cases) do
			local sg_slot = case .. "_sg"
			if active_slots then
				iut.insert_forms(word_spec.forms, sg_slot, handle_overriding_forms(lemma, stem, indefinite_singulars, accent_and_form_spec))
			end
			local pl_slot = case .. "_pl"
			if active_slots then
				iut.insert_forms(word_spec.forms, pl_slot, handle_overriding_forms(lemma, stem, indefinite_plurals, accent_and_form_spec))
			end
		end
	end
end


-- Decline the noun in WORD_SPEC (an object as returned by parse_simplified_specification()).
-- This sets the form values in `WORD_SPEC.forms` for all slots. (If a given slot has no values,
-- it will not be present in `WORD_SPEC.forms`.)
local function decline_noun(word_spec, active_slots, include_definite)
	for _, accent_and_form_spec in ipairs(word_spec.accent_and_form_specs) do
		if accent_and_form_spec.accent_spec.is_adj then
			local active_adj_slots = convert_active_noun_slots_to_active_adj_slots(active_slots)
			decline_one_adj(word_spec, accent_and_form_spec, active_adj_slots, active_slots, include_definite)
		else
			decline_one_noun(word_spec, accent_and_form_spec, active_slots, include_definite)
		end
	end
end


local decline_multiword_or_alternant_multiword_spec


-- Decline the noun or adjective alternants in ALTERNANT_SPEC (an object as returned by
-- parse_simplified_specification_allowing_alternants()). This sets the form values
-- in `ALTERNANT_SPEC.forms` for all slots. (If a given slot has no values, it will
-- not be present in `ALTERNANT_SPEC.forms`). It also sets `ALTERNANT_SPEC.forms.lemma`,
-- which is a list of strings to use as lemmas (e.g. in the title of the generated table
-- and in accelerators).
local function decline_alternants(alternant_spec, active_slots, is_adj, include_definite)
	alternant_spec.forms = {}
	if active_slots.comp then
		alternant_spec.compforms = {}
		alternant_spec.supforms = {}
	end
	local include_definite_at_end = include_definite
	for _, multiword_spec in ipairs(alternant_spec.alternants) do
		include_definite_at_end = decline_multiword_or_alternant_multiword_spec(
			multiword_spec, active_slots, is_adj, include_definite)
		for slot, _ in pairs(active_slots) do
			iut.insert_forms(alternant_spec.forms, slot, multiword_spec.forms)
			if is_adj and active_slots.comp then
				iut.insert_forms(alternant_spec.compforms, slot, multiword_spec.compforms)
				iut.insert_forms(alternant_spec.supforms, slot, multiword_spec.supforms)
			end
		end
	end
	return include_definite_at_end
end


local function append_forms(formtable, slot, forms, before_text)
	local old_forms = formtable
	if #forms == 1 then
		-- If there's only one new form, destructively modify the existing
		-- forms and notes for this new form and its footnotes.
		local form = forms
		for _, old_form in ipairs(old_forms) do
			old_form.form = old_form.form .. before_text .. form.form
			if form.footnotes and #form.footnotes > 0 then
				if not old_form.footnotes then
					old_form.footnotes = {}
				end
				for _, footnote in ipairs(form.footnotes) do
					m_table.insertIfNot(old_form.footnotes, footnote)
				end
			end
		end
	else
		-- If there are multiple new forms, we need to loop over all
		-- combinations of new and old forms. In that case, use a new table
		-- for the combined forms.
		local ret_forms = {}
		for _, old_form in ipairs(old_forms) do
			for _, form in ipairs(forms) do
				-- Do a shallow copy of the footnotes because we may modify them in-place.
				local new_form = {form=old_form.form .. before_text .. form.form,
					footnotes=m_table.shallowcopy(old_form.footnotes)}
				if form.footnotes and #form.footnotes > 0 then
					if not new_form.footnotes then
						new_form.footnotes = {}
					end
					for _, footnote in ipairs(form.footnotes) do
						m_table.insertIfNot(new_form.footnotes, footnote)
					end
				end
				table.insert(ret_forms, new_form)
			end
		end
		formtable = ret_forms
	end
end


decline_multiword_or_alternant_multiword_spec = function(multiword_spec, active_slots, is_adj, include_definite)
	multiword_spec.forms = {}
	if active_slots.comp then
		multiword_spec.compforms = {}
		multiword_spec.supforms = {}
	end
	for slot, _ in pairs(active_slots) do
		multiword_spec.forms = {{form=""}}
		if active_slots.comp then
			multiword_spec.compforms = {{form=""}}
			multiword_spec.supforms = {{form=""}}
		end
	end

	local is_alternant_multiword = not not multiword_spec.alternant_or_word_specs
	for _, word_spec in ipairs(is_alternant_multiword and multiword_spec.alternant_or_word_specs or multiword_spec.word_specs) do
		if word_spec.alternants then
			include_definite = decline_alternants(word_spec, active_slots, is_adj, include_definite)
		elseif is_adj then
			decline_adj(word_spec, active_slots, include_definite)
			include_definite = false
		else
			decline_noun(word_spec, active_slots, include_definite)
			include_definite = not word_spec.accent_and_form_specs.accent_spec.is_adj
		end
		for slot, _ in pairs(active_slots) do
			if word_spec.forms then
				append_forms(multiword_spec.forms, slot, word_spec.forms, word_spec.before_text)
			end
			if word_spec.compforms and word_spec.compforms then
				append_forms(multiword_spec.compforms, slot, word_spec.compforms, word_spec.before_text)
			end
			if word_spec.supforms and word_spec.supforms then
				append_forms(multiword_spec.supforms, slot, word_spec.supforms, word_spec.before_text)
			end
		end
	end
	if multiword_spec.post_text ~= "" then
		local pseudoform = {{form=""}}
		for slot, _ in pairs(active_slots) do
			append_forms(multiword_spec.forms, slot, pseudoform, multiword_spec.post_text)
			if active_slots.comp then
				append_forms(multiword_spec.compforms, slot, pseudoform, multiword_spec.post_text)
				append_forms(multiword_spec.supforms, slot, pseudoform, multiword_spec.post_text)
			end
		end
	end

	if is_alternant_multiword then
		multiword_spec.n = active_slots.n
		local lemma_slot =
			multiword_spec.forms.ind_m_pl and "ind_m_pl" or -- два
			multiword_spec.forms.nom_m_sg and "nom_m_sg" or -- кой, то́зи, etc.
			multiword_spec.forms.m_sg and "m_sg" or -- чий, какъ́в, такъ́в, etc.
			is_adj and "ind_m_sg" or
			multiword_spec.n == "pl" and "ind_pl" or
			"ind_sg"
		multiword_spec.forms.lemma = {}
		for _, form in ipairs(multiword_spec.forms) do
			m_table.insertIfNot(multiword_spec.forms.lemma, form.form)
		end
	end

	return include_definite
end


-- Convert `ALTERNANT_MULTIWORD_SPEC.forms` (for ALTERNANT_MULTIWORD_SPEC as returned by
-- parse_simplified_specification_allowing_alternants()) for all slots into displayable text.
-- This also sets ALTERNANT_MULTIWORD_SPEC.combined_def_sg to true if the definite subjective and
-- objective singular forms are the same (and hence should be combined in the generated table),
-- and sets ALTERNANT_MULTIWORD_SPEC.forms.footnote to the combined string to insert as a footnote
-- (if there are no footnotes, it will be the empty string).
local function show_forms(alternant_multiword_spec, is_adj)
	local lemmas = {}
	for _, lemma in ipairs(alternant_multiword_spec.forms.lemma) do
		table.insert(lemmas, com.remove_monosyllabic_stress(lemma))
	end
	local accel_lemma = lemmas
	alternant_multiword_spec.forms.lemma = table.concat(lemmas, ", ")

	local function get_slot_to_accel_form(combined_def_sg)
		return function(slot)
			local accel_form = is_adj and adj_slots or noun_slots
			-- HACK!
			if combined_def_sg and slot == "def_sub_sg" then
				accel_form = "def|s"
			end
			return accel_form
		end
	end

	local footnote_obj = com.init_footnote_obj()

	if is_adj then
		local slot_to_accel_form = get_slot_to_accel_form(false)
		com.display_forms(footnote_obj, alternant_multiword_spec.forms, alternant_multiword_spec.forms,
			adj_slots, false, accel_lemma, slot_to_accel_form)
		if alternant_multiword_spec.compforms then
			com.display_forms(footnote_obj, alternant_multiword_spec.compforms, alternant_multiword_spec.compforms,
				adj_slots, false, accel_lemma, slot_to_accel_form)
		end
		if alternant_multiword_spec.supforms then
			com.display_forms(footnote_obj, alternant_multiword_spec.supforms, alternant_multiword_spec.supforms,
				adj_slots, false, accel_lemma, slot_to_accel_form)
		end
	else
		-- For def_sub_sg and def_obj_sg, first compute "raw" (unlinked) forms so we can
		-- compare them properly; linked forms have accelerator info in them which differs
		-- between sub and obj.
		local raw_forms = {}
		com.display_forms(footnote_obj, alternant_multiword_spec.forms, raw_forms, {"def_sub_sg", "def_obj_sg"},
			"is list", accel_lemma, get_slot_to_accel_form(true), "raw")
		-- Then generate the linked forms, using a special accelerator form if the def_sub_sg and def_obj_sg are the same.
		alternant_multiword_spec.combined_def_sg = raw_forms.def_sub_sg == raw_forms.def_obj_sg
		com.display_forms(footnote_obj, alternant_multiword_spec.forms, alternant_multiword_spec.forms, noun_slots,
			false, accel_lemma, get_slot_to_accel_form(alternant_multiword_spec.combined_def_sg))
	end
	if alternant_multiword_spec.footnote then
		table.insert(footnote_obj.notes, alternant_multiword_spec.footnote)
	end
	alternant_multiword_spec.forms.footnote = table.concat(footnote_obj.notes, "<br />")
end


-- Generate the displayable table of all noun forms, given ALTERNANT_MULTIWORD_SPEC (as returned
-- by parse_alternant_multiword_spec()) where show_forms() has already been called to convert
-- `ALTERNANT_MULTIWORD_SPEC.forms` into a table of strings.
local function make_noun_table(alternant_multiword_spec)
	local num = alternant_multiword_spec.n
	local forms = alternant_multiword_spec.forms

	local table_begin = [=[
<div class="NavFrame" style="max-width: 50em;">
<div class="NavHead" style="background: #eff7ff;">{title}</div>
<div class="NavContent">
{\op}| border="1px solid #000000" style="border-collapse: collapse; background: #F9F9F9; width: 100%;" class="inflection-table"
! style="width: 33%; background: #d9ebff; " |
! style="font-size: 90%; background: #d9ebff;" | singular
! style="font-size: 90%; background: #d9ebff;" | plural
|-
! style="font-size:90%; background: #eff7ff;" | indefinite
| {ind_sg}
| {ind_pl}
|-
]=]

	local table_cont_def_split = [=[
! style="font-size: 90%; background: #eff7ff;" | definite<br>(subject form)
| {def_sub_sg}
| rowspan="2" | {def_pl}
|-
! style="font-size: 90%; background: #eff7ff;" | definite<br>(object form)
| {def_obj_sg}
]=]

	local table_cont_def_combined = [=[
! style="font-size: 90%; background: #eff7ff;" | definite
| {def_sub_sg}
| {def_pl}
]=]

	local table_cont_count = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | count form
| —
| {count}
]=]

	local table_cont_voc = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | vocative form
| {voc_sg}
| {voc_pl}
]=]

	local table_cont_acc = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | accusative form
| {acc_sg}
| {acc_pl}
]=]

	local table_cont_gen = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | genitive form
| {gen_sg}
| {gen_pl}
]=]

	local table_cont_dat = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | dative form
| {dat_sg}
| {dat_pl}
]=]

	local table_end = [=[
|{\cl}{notes_clause}</div></div>]=]

	local table_sg_begin = [=[
<div class="NavFrame" style="max-width: 30em;">
<div class="NavHead" style="background: #eff7ff;">{title}</div>
<div class="NavContent">
{\op}| border="1px solid #000000" style="border-collapse: collapse; background: #F9F9F9; width: 100%;" class="inflection-table"
! style="width: 50%; background: #d9ebff; " |
! style="font-size: 90%; background: #d9ebff;" | singular
|-
! style="font-size:90%; background: #eff7ff;" | indefinite
| {ind_sg}
|-
]=]

	local table_sg_cont_def_split = [=[
! style="font-size: 90%; background: #eff7ff;" | definite<br>(subject form)
| {def_sub_sg}
|-
! style="font-size: 90%; background: #eff7ff;" | definite<br>(object form)
| {def_obj_sg}
]=]

	local table_sg_cont_def_combined = [=[
! style="font-size: 90%; background: #eff7ff;" | definite
| {def_sub_sg}
]=]

	local table_sg_cont_voc = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | vocative form
| {voc_sg}
]=]

	local table_sg_cont_acc = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | accusative form
| {acc_sg}
]=]

	local table_sg_cont_gen = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | genitive form
| {gen_sg}
]=]

	local table_sg_cont_dat = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | dative form
| {dat_sg}
]=]

	local table_pl = [=[
<div class="NavFrame" style="max-width: 30em;">
<div class="NavHead" style="background: #eff7ff;">{title}</div>
<div class="NavContent">
{\op}| border="1px solid #000000" style="border-collapse: collapse; background: #F9F9F9; width: 100%;" class="inflection-table"
! style="width: 50%; background: #d9ebff; " |
! style="font-size: 90%; background: #d9ebff;" | plural
|-
! style="font-size:90%; background: #eff7ff;" | indefinite
| {ind_pl}
|-
! style="font-size: 90%; background: #eff7ff;" | definite
| {def_pl}
]=]

	local table_pl_cont_voc = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | vocative form
| {voc_pl}
]=]

	local table_pl_cont_acc = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | accusative form
| {acc_pl}
]=]

	local table_pl_cont_gen = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | genitive form
| {gen_pl}
]=]

	local table_pl_cont_dat = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | dative form
| {dat_pl}
]=]

	local table_spec
	if num == "sg" then
		table_spec = table_sg_begin ..
			(alternant_multiword_spec.combined_def_sg and table_sg_cont_def_combined or table_sg_cont_def_split) ..
			(forms.voc_sg ~= "—" and table_sg_cont_voc or "") ..
			(forms.acc_sg ~= "—" and table_sg_cont_acc or "") ..
			(forms.gen_sg ~= "—" and table_sg_cont_gen or "") ..
			(forms.dat_sg ~= "—" and table_sg_cont_dat or "") ..
			table_end
	elseif num == "pl" then
		table_spec = table_pl ..
			(forms.voc_pl ~= "—" and table_pl_cont_voc or "") ..
			(forms.acc_pl ~= "—" and table_pl_cont_acc or "") ..
			(forms.gen_pl ~= "—" and table_pl_cont_gen or "") ..
			(forms.dat_pl ~= "—" and table_pl_cont_dat or "") ..
			table_end
	else
		table_spec = table_begin ..
			(alternant_multiword_spec.combined_def_sg and table_cont_def_combined or table_cont_def_split) ..
			(forms.count ~= "—" and table_cont_count or "") ..
			((forms.voc_sg ~= "—" or forms.voc_pl ~= "—") and table_cont_voc or "") ..
			((forms.acc_sg ~= "—" or forms.acc_pl ~= "—") and table_cont_acc or "") ..
			((forms.gen_sg ~= "—" or forms.gen_pl ~= "—") and table_cont_gen or "") ..
			((forms.dat_sg ~= "—" or forms.dat_pl ~= "—") and table_cont_dat or "") ..
			table_end
	end

	local notes_template = [===[
<div style="width:100%;text-align:left;background:#d9ebff">
<div style="display:inline-block;text-align:left;padding-left:1em;padding-right:1em">
{footnote}
</div></div>
]===]

	forms.notes_clause = forms.footnote ~= "" and m_string_utilities.format(notes_template, forms) or ""
	forms.title = alternant_multiword_spec.title or "Declension of " .. forms.lemma
	return m_string_utilities.format(table_spec, forms)
end


-- Generate the displayable table of all adjective forms, given ALTERNANT_MULTIWORD_SPEC (as returned
-- by parse_alternant_multiword_spec()) where show_forms() has already been called to convert
-- `ALTERNANT_MULTIWORD_SPEC.forms` into a table of strings.
local function make_adj_table(alternant_multiword_spec)
	local forms = alternant_multiword_spec.forms
	local table_normal_koj_begin = [=[
<div class="NavFrame" style="max-width: 50em;">
<div class="NavHead" style="background: #eff7ff;">{title}</div>
<div class="NavContent">
{\op}| border="1px solid #000000" style="border-collapse: collapse; background: #F9F9F9; width: 100%;" class="inflection-table"
! style="width: 33%; background: #d9ebff; " |
! style="font-size: 90%; background: #d9ebff;" | masculine
! style="font-size: 90%; background: #d9ebff;" | feminine
! style="font-size: 90%; background: #d9ebff;" | neuter
! style="font-size: 90%; background: #d9ebff;" | plural
|-
]=]

	local table_cont_indef_def = [=[
! style="font-size: 90%; background: #eff7ff;" | indefinite
| {ind_m_sg}
| {ind_f_sg}
| {ind_n_sg}
| {ind_pl}
|-
! style="font-size: 90%; background: #eff7ff;" | definite<br />(subject form)
| {def_sub_m_sg}
| rowspan="2" | {def_f_sg}
| rowspan="2" | {def_n_sg}
| rowspan="2" | {def_pl}
|-
! style="font-size: 90%; background: #eff7ff;" | definite<br />(object form)
| {def_obj_m_sg}
]=]

	local table_cont_koj = [=[
! style="font-size: 90%; background: #eff7ff;" | nominative
| {nom_m_sg}
| rowspan="3" | {f_sg}
| rowspan="3" | {n_sg}
| rowspan="3" | {pl}
|-
! style="font-size: 90%; background: #eff7ff;" | accusative
| {acc_m_sg}
|-
! style="font-size: 90%; background: #eff7ff;" | dative
| {dat_m_sg}
]=]

	local table_cont_short = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | short form
| colspan="4" | {short}
]=]

	local table_cont_voc = [=[
|-
! style="font-size: 90%; background: #eff7ff;" | extended<br />(vocative form)
| {voc_m_sg}
]=]

	local table_dva_begin = [=[
<div class="NavFrame" style="width: 25em;">
<div class="NavHead" style="background: #eff7ff;">{title}</div>
<div class="NavContent">
{\op}| border="1px solid #000000" style="border-collapse: collapse; background: #F9F9F9; width: 100%;" class="inflection-table"
! style="width: 33%; background: #d9ebff; " |
! style="font-size: 90%; background: #d9ebff;" | masculine
! style="font-size: 90%; background: #d9ebff;" | feminine/<br />neuter
|-
! style="font-size: 90%; background: #eff7ff;" | indefinite
| {ind_m_pl}
| {ind_fn_pl}
|-
! style="font-size: 90%; background: #eff7ff;" | definite
| {def_m_pl}
| {def_fn_pl}
]=]

	local table_chij_begin = [=[
<div class="NavFrame" style="width: 35em;">
<div class="NavHead" style="background: #eff7ff;">{title}</div>
<div class="NavContent">
{\op}| border="1px solid #000000" style="border-collapse: collapse; background: #F9F9F9; width: 100%;" class="inflection-table"
! style="font-size: 90%; background: #d9ebff;" | masculine
! style="font-size: 90%; background: #d9ebff;" | feminine
! style="font-size: 90%; background: #d9ebff;" | neuter
! style="font-size: 90%; background: #d9ebff;" | plural
|-
| {m_sg}
| {f_sg}
| {n_sg}
| {pl}
]=]

	local table_end = [=[
|{\cl}{notes_clause}</div></div>]=]

	local notes_template = [===[
<div style="width:100%;text-align:left;background:#d9ebff">
<div style="display:inline-block;text-align:left;padding-left:1em;padding-right:1em">
{footnote}
</div></div>
]===]

	local special_title = alternant_multiword_spec.title or "Declension of " .. forms.lemma
	forms.notes_clause = forms.footnote ~= "" and m_string_utilities.format(notes_template, forms) or ""
	if forms.ind_m_pl ~= "—" then -- два
		local table_spec = table_dva_begin .. table_end
		forms.title = special_title
		return m_string_utilities.format(table_spec, forms)
	elseif forms.nom_m_sg ~= "—" then -- кой, etc.
		local table_spec = table_normal_koj_begin .. table_cont_koj .. table_end
		forms.title = special_title
		return m_string_utilities.format(table_spec, forms)
	elseif forms.m_sg ~= "—" then -- чий, etc.
		local table_spec = table_chij_begin .. table_end
		forms.title = special_title
		return m_string_utilities.format(table_spec, forms)
	else
		local table_spec = table_normal_koj_begin ..
			table_cont_indef_def ..
			(forms.short ~= "—" and table_cont_short or "") ..
			(forms.voc_m_sg ~= "—" and table_cont_voc or "") ..
			table_end
		if alternant_multiword_spec.compforms or alternant_multiword_spec.supforms then
			forms.title = alternant_multiword_spec.title or "Positive forms of " .. forms.lemma
		else
			forms.title = special_title .. " (no comparative)"
		end
		local postable = m_string_utilities.format(table_spec, forms)
		local comptable = ""
		local suptable = ""
		if alternant_multiword_spec.compforms then
			alternant_multiword_spec.compforms.notes_clause = forms.notes_clause
			alternant_multiword_spec.compforms.title = "Comparative forms of " .. forms.lemma
			comptable = m_string_utilities.format(table_spec, alternant_multiword_spec.compforms)
		end
		if alternant_multiword_spec.supforms then
			alternant_multiword_spec.supforms.notes_clause = forms.notes_clause
			alternant_multiword_spec.supforms.title = "Superlative forms of " .. forms.lemma
			suptable = m_string_utilities.format(table_spec, alternant_multiword_spec.supforms)
		end
		return postable .. comptable .. suptable
	end
end


-- Concatenate all forms of all slots into a single string of the form
-- "SLOT=FORM,FORM,...|SLOT=FORM,FORM,...|...". Embedded pipe symbols (as might occur
-- in embedded links) are converted to <!>. If INCLUDE_PROPS is given, also include
-- additional properties (currently, only "|n=NUMBER"). This is for use by bots.
local function concat_forms(alternant_multiword_spec, include_props, is_adj)
	local ins_text = {}
	local n = alternant_multiword_spec.n
	local function skip_slot(slot)
		return n == "sg" and rfind(slot, "_pl$") or n == "pl" and (slot == "count" or rfind(slot, "_sg$"))
	end
	for slot, _ in pairs(is_adj and adj_slots or noun_slots) do
		if not skip_slot(slot) then
			local formtext = com.concat_forms_in_slot(alternant_multiword_spec.forms)
			if formtext then
				table.insert(ins_text, slot .. "=" .. formtext)
			end
		end
	end
	for _, slot in ipairs(is_adj and potential_adj_lemma_slots or potential_noun_lemma_slots) do
		if not skip_slot(slot) then
			slot = "linked_" .. slot
			local formtext = com.concat_forms_in_slot(alternant_multiword_spec.forms)
			if formtext then
				table.insert(ins_text, slot .. "=" .. formtext)
			end
		end
	end
	if include_props then
		if is_adj then
			table.insert(ins_text, "comp=" .. (alternant_multiword_spec.comparable and "1" or "0"))
		else
			if alternant_multiword_spec.n then
				table.insert(ins_text, "n=" .. alternant_multiword_spec.n)
			end
		end
	end
	return table.concat(ins_text, "|")
end


-- Externally callable function to parse and decline a noun given user-specified arguments.
-- Return value is ALTERNANT_MULTIWORD_SPEC, an object where the declined forms are in
-- `ALTERNANT_MULTIWORD_SPEC.forms` for each slot. If there are no values for a slot, the
-- slot key will be missing. The value for a given slot is a list of objects
-- {form=FORM, footnotes=FOOTNOTES}.
function export.do_generate_noun_forms(parent_args, pos, from_headword, def, support_num_type)
	local params = {
		 = {required = true, default = def or "бряг<b>"},
		footnote = {},
		title = {},
	}
	if from_headword then
		params.lemma = {list = true}
		params.id = {}
		params.pos = {default = pos}
		params.cat = {list = true}
		params.indecl = {type = "boolean"}
		params.m = {list = true}
		params.f = {list = true}
		params.g = {list = true}
	end
	if support_num_type then
		params = {}
	end

	local args = m_para.process(parent_args, params)

	pos = args.pos or pos -- args.pos only set when from_headword
	
	local alternant_multiword_spec = parse_alternant_multiword_spec(args)
	check_lemma_stress(alternant_multiword_spec)
	detect_all_noun_accent_and_form_specs(alternant_multiword_spec)
	local active_slots = compute_overall_active_noun_slots(alternant_multiword_spec)
	construct_noun_stems(alternant_multiword_spec)
	decline_multiword_or_alternant_multiword_spec(alternant_multiword_spec, active_slots, false,
		"include definite")
	alternant_multiword_spec.forms.lemma = args.lemma and #args.lemma > 0 and args.lemma or alternant_multiword_spec.forms.lemma
	alternant_multiword_spec.title = args.title
	return alternant_multiword_spec
end


-- Externally callable function to parse and decline an adjective given user-specified arguments.
-- Return value is ALTERNANT_MULTIWORD_SPEC, an object where the declined forms are in
-- `ALTERNANT_MULTIWORD_SPEC.forms` for each slot. If there are no values for a slot, the slot
-- key will be missing. The value for a given slot is a list of objects
-- {form=FORM, footnotes=FOOTNOTES}.
function export.do_generate_adj_forms(parent_args, pos, from_headword, def, support_num_type)
	local params = {
		 = {required = true, default = def or "бял<(я)>"},
		footnote = {},
		title = {},
	}
	if from_headword then
		params.lemma = {list = true}
		params.id = {}
		params.pos = {default = pos}
		params.cat = {list = true}
		params.indecl = {type = "boolean"}
	end
	if support_num_type then
		params = {}
	end

	local args = m_para.process(parent_args, params)

	pos = args.pos or pos -- args.pos only set when from_headword
	
	local alternant_multiword_spec = parse_alternant_multiword_spec(args, "is adj")
	check_lemma_stress(alternant_multiword_spec)
	detect_all_adj_accent_and_form_specs(alternant_multiword_spec)
	local active_slots = compute_overall_active_adj_slots(alternant_multiword_spec)
	construct_adj_stems(alternant_multiword_spec)
	decline_multiword_or_alternant_multiword_spec(alternant_multiword_spec, active_slots, "is adj",
		"include definite")
	alternant_multiword_spec.forms.lemma = args.lemma and #args.lemma > 0 and args.lemma or alternant_multiword_spec.forms.lemma
	alternant_multiword_spec.title = args.title
	return alternant_multiword_spec
end


-- Main entry point for nouns. Template-callable function to parse and decline a noun given
-- user-specified arguments and generate a displayable table of the declined forms.
function export.show_noun(frame)
	local parent_args = frame:getParent().args
	local alternant_multiword_spec = export.do_generate_noun_forms(parent_args, "nouns")
	show_forms(alternant_multiword_spec)
	return make_noun_table(alternant_multiword_spec)
end


-- Main entry point for adjectives. Template-callable function to parse and decline an adjective given
-- user-specified arguments and generate a displayable table of the declined forms.
function export.show_adj(frame)
	local parent_args = frame:getParent().args
	local alternant_multiword_spec = export.do_generate_adj_forms(parent_args, "adjectives")
	show_forms(alternant_multiword_spec, "is adj")
	return make_adj_table(alternant_multiword_spec)
end


-- Template-callable function to parse and decline a noun given user-specified arguments and return
-- the forms as a string "SLOT=FORM,FORM,...|SLOT=FORM,FORM,...|...". Embedded pipe symbols (as might
-- occur in embedded links) are converted to <!>. If |include_props=1 is given, also include
-- additional properties (currently, only "|n=NUMBER"). This is for use by bots.
function export.generate_noun_forms(frame)
	local include_props = frame.args
	local parent_args = frame:getParent().args
	local alternant_multiword_spec = export.do_generate_noun_forms(parent_args, "nouns")

	return concat_forms(alternant_multiword_spec, include_props)
end


-- Template-callable function to parse and decline an adjective given user-specified arguments and return
-- the forms as a string "SLOT=FORM,FORM,...|SLOT=FORM,FORM,...|...". Embedded pipe symbols (as might
-- occur in embedded links) are converted to <!>. If |include_props=1 is given, also include
-- additional properties (currently, only "|comp=1" if comparable). This is for use by bots.
function export.generate_adj_forms(frame)
	local include_props = frame.args
	local parent_args = frame:getParent().args
	local alternant_multiword_spec = export.do_generate_adj_forms(parent_args, "adjectives")

	return concat_forms(alternant_multiword_spec, include_props)
end


return export
Module:bg-nominal

Wikious

Boobota

Sagapedia
