モジュール:fr-verb

このモジュールについての説明文ページを モジュール:fr-verb/doc に作成できます

--[=[

Author: Kc kennylau; significant rewriting by Benwing

This implements {{fr-conj-auto}}. It uses the following submodules:
* [[Module:fr-verb/core]] (helper for generating conjugations)
* [[Module:fr-verb/pron]] (helper for generating pronunciations of conjugations)
* [[Module:fr-conj]] (for constructing the table wikicode given the forms)
* [[Module:fr-pron]] (for generating pronunciations of stems)

FIXME:

1. (DONE) Use ‿ to join reflexive pronouns.
2. montre-toi needs a schwa in it.
3. 'etre' and 'avoir_or_etre' tables should be moved to the template call.
3a. (DONE) Make sure aux= is supported at the template level.
4. Implement 'aspirated h'; not all vowel-initial verbs have elision with
   reflexive pronouns.
5. Document the various override arguments.
6. Implement conjugation for -éyer.
7. (MAYBE? MAYBE NOT NECESSARY, {{fr-conj-ir}} doesn't seem to use it,
   MAYBE ALREADY DONE IN THE HEADWORD CODE?) Implement sort= for sort key,
   and handle most cases automatically (e.g. chérir with sort=cherir).
8. (DONE) Copy notes from {{fr-conj-ir}} to our conj["ir"].
9. (DONE) Lots of other conjugations needed. Consider generalizing existing code
   so a minimal number of principal parts can be given and all the conjugation
   and pronunciation derived.
10. (DONE) Convert remaining use of old templates to use {{fr-conj-auto}}.
11. (DONE) Figure out what the COMBINING flag in [[Module:fr-pron]] does and
    remove it, including all calls from this module.
12. (ALREADY DONE) Support sevrer, two-stem e/è verb.
13. (DONE) Autodetect e-er verbs including eCer as well as eCler and eCrer verbs
    like sevrer, and eguer/equer (if they exist). Make sure there aren't
	verbs of this form that aren't e-er by looking for them in the list of
	fr-conj-auto verbs that have an empty typ arg (possibly enough to look
	at all fr-conj-auto verbs).
14. Check pronunciation of 'pleuvoir'. TLFi says /pløvwaʁ/, frwikt says /plœvwaʁ/.
15. (DONE) Check if -er-type conjugations of -aillir, -cueillir, braire are
    correct.
16. (DONE) Fix notes for prefixed croitre/croître verbs, based on the old-style
	templates.
17. (DONE) Implement impersonal and only-third verbs, including impers=
    and onlythird=.
18. (DONE) Fix schwa in -ayer, -eyer pronunciation and check other uses of
    ind_f() to see if they need a fut_stem_i.
19. Implement sort key in {{fr-verb}}. Should map accented letters to
    unaccented letters and rearrange "se regarded" to "regarded, se" and
    similarly for "s'infiltrer".
20. "se regarder" should have optional schwa in re-.

Remaining templates:

-- copier-coller: FIXME, eventually implement general suppot for verbs like this
--]=]

-- Table of exported functions.
local export = {}
-- Table of conjugation functions. The keys are verbal suffixes (e.g. "ir",
-- "iller") and the values are no-argument functions that apply to verbs whose
-- infinitive contains that suffix, unless the verb also matches a conjugation
-- corresponding to a longer suffix. The values take all info on the verb
-- from 'data' (see below) and set properties of 'data' to indicate the
-- verb forms and pronunciation.
local conj = {}

-- If not false, compare this module with new version of module to make
-- sure all conjugations and pronunciations are the same. If "error", issue
-- an error whenever they are different, with the contents of the error
-- indicating the different forms; otherwise, use the tracking category
-- [[Template:tracking/fr-verb/different-conj]] (see what links there to see
-- the differing verbs; there's also [[Template:tracking/fr-verb/same-conj]]
-- for the verbs that don't differ, which can be used to verify that all verbs
-- have been processed, as it takes awhile for this to happen).
local test_new_fr_verb_module = false

local m_core = require("モジュール:fr-verb/core")
local m_pron = require("モジュール:fr-verb/pron")
local m_links = require("モジュール:links")
local m_conj = require("モジュール:fr-conj")
local m_fr_pron = require("モジュール:fr-pron")
local lang = require("モジュール:languages").getByCode("fr")
local ut = require("モジュール:utils")
local m_utilities = require("モジュール:utilities")
local m_debug = require("モジュール:debug")

local u = mw.ustring.char
local rfind = mw.ustring.find
local rsubn = mw.ustring.gsub
local rmatch = mw.ustring.match
local rsplit = mw.text.split
local ulower = mw.ustring.lower
local uupper = mw.ustring.upper
local usub = mw.ustring.sub
local ulen = mw.ustring.len

local written_vowel = "aàâeéèêiîoôuûäëïöüÿ"
local written_cons_c = "[^%-" .. written_vowel .. "]"
local written_cons_no_cgy_c = "[^%-cgy" .. written_vowel .. "]"
local written_cons_no_cgyx_c = "[^%-cgyx" .. written_vowel .. "]"
local written_cons_no_lryx_c = "[^%-lryx" .. written_vowel .. "]"

-- 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

local function map(seq, fun)
	if type(seq) == "table" then
		local ret = {}
		for _, s in ipairs(seq) do
			-- store in separate var in case fun() has multiple retvals
			local retval = fun(s)
			table.insert(ret, retval)
		end
		return ret
	else
		-- store in separate var in case fun() has multiple retvals
		local retval = fun(seq)
		return retval
	end
end

local function IPA(str)
	return require("モジュール:IPA").format_IPA(nil, str)
end

local function pron(str)
	return m_fr_pron.show(str, "v")
end

local function dopron(data, stem, suffix)
	suffix = suffix or ""
	return map(stem, function(s)
		return pron((data and data.pronstem or "") .. s .. suffix)
	end)
end

local function setform(data, form, val)
	data.forms[form] = val
	data.prons[form] = dopron(data, val)
end

local all_verb_props = {
	"inf", "pp", "ppr",
	"inf_nolink", "pp_nolink", "ppr_nolink",
	"ind_p_1s", "ind_p_2s", "ind_p_3s", "ind_p_1p", "ind_p_2p", "ind_p_3p",
	"ind_i_1s", "ind_i_2s", "ind_i_3s", "ind_i_1p", "ind_i_2p", "ind_i_3p",
	"ind_ps_1s", "ind_ps_2s", "ind_ps_3s", "ind_ps_1p", "ind_ps_2p", "ind_ps_3p",
	"ind_f_1s", "ind_f_2s", "ind_f_3s", "ind_f_1p", "ind_f_2p", "ind_f_3p",
	"cond_p_1s", "cond_p_2s", "cond_p_3s", "cond_p_1p", "cond_p_2p", "cond_p_3p",
	"sub_p_1s", "sub_p_2s", "sub_p_3s", "sub_p_1p", "sub_p_2p", "sub_p_3p",
	"sub_pa_1s", "sub_pa_2s", "sub_pa_3s", "sub_pa_1p", "sub_pa_2p", "sub_pa_3p",
	"imp_p_2s", "imp_p_1p", "imp_p_2p"
}

-- List of verbs are conjugated using 'être' in the passé composé.
-- FIXME: This should be in the template, not here.
local etre = {
	"aller",
	"apparaitre", "apparaître",
	"arriver",
	"entrer",
	"mourir",
	"naitre", "naître", "renaitre", "renaître",
	"partir", "repartir",
	"repasser",
	"rester",
	"surmener",
	"retomber",
	"venir", "advenir", "bienvenir", "devenir", "intervenir", "obvenir", "parvenir", "provenir", "redevenir", "revenir", "survenir"
}

for _,key in ipairs(etre) do
	etre[key] = true
end

-- List of verbs that can be conjugated using either 'avoir' or 'être' in the
-- passé composé. FIXME: This should be in the template, not here.
local avoir_or_etre = {
	"descendre", "monter", "paraitre", "paraître", "passer",
	"rentrer", "repartir", "ressortir", "retourner", "réapparaitre", "réapparaître",
	"sortir", "tomber"
}

for _,key in ipairs(avoir_or_etre) do
	avoir_or_etre[key] = true
end

-- Table mapping verb suffixes to other verb suffixes that they are
-- conjugated the same as. Only required when there is a shorter-length
-- suffix of the verb that has a different conjugation (in this case,
-- 'naitre' and 'naître').
local alias = {
	["connaitre"] = "aitre",
	["connaître"] = "aître",
}

-- List of -ir verbs that do not take -iss- infix.
local ir_s = {
	"dormir", "endormir", "redormir", "rendormir",
	"partir", "départir", "repartir",
	"sortir", "ressortir",
	"sentir", "assentir", "consentir", "pressentir", "ressentir",
	"mentir", "démentir",
	"servir", "desservir", "resservir",
	"repentir"
}
for _,key in ipairs(ir_s) do
	ir_s[key] = true
end

local function link(term, alt)
	return m_links.full_link({lang = lang, term = term, alt = alt}, "term")
end

-- Clone parent's args while also assigning nil to empty strings.
local function clone_args(frame)
	local args = {}
	for pname, param in pairs(frame:getParent().args) do
		if param == "" then args[pname] = nil
		else args[pname] = param
		end
	end
	return args
end

local function track(page)
	m_debug.track("fr-verb/" .. page)
	return true
end

local function unsupported_pron(data)
	if data.pron then
		error("Pronunciation respelling (pron=) not supported for this verb")
	end
end

-- Remove the expected ending ENDING from IPA pronunciation PRON (possibly
-- nil); error if ending not present.
local function strip_pron_ending(pron, ending)
	if not pron then
		return nil
	end
	return map(pron, function(val)
		if not rfind(val, ending .. "$") then
			error('Internal error: expected pronunciation "' .. val .. '" to end with "' .. ending .. '"')
		end
		return rsub(val, ending .. "$", "")
	end)
end

-- Remove the expected ending ENDING from respelling pronunciation PRON
-- (possibly nil or a sequence); error if ending not present.
local function strip_respelling_ending(pron, ending)
	if not pron then
		return nil
	end
	return map(pron, function(val)
		if not rfind(val, ending .. "$") then
			error('Expected respelling "' .. val .. '" to end with "' .. ending .. '"')
		end
		return rsub(val, ending .. "$", "")
	end)
end

-- Remove the expected beginning BEGINNING from respelling pronunciation PRON
-- (possibly nil); error if beginning not present. If SPLIT, split the value
-- of PRON on comma, strip the beginning from each component, and paste
-- together.
local function strip_respelling_beginning(pron, beginning, split)
	if not pron then
		return nil
	end
	if split then
		local pronvals = rsplit(pron, ",")
		local stripped_pronvals = {}
		for _, pronval in ipairs(pronvals) do
			table.insert(stripped_pronvals, strip_respelling_beginning(pronval, beginning))
		end
		return table.concat(stripped_pronvals, ",")
	end
	if not rfind(pron, "^" .. beginning) then
		error('Expected respelling "' .. pron .. '" to begin with "' .. beginning .. '"')
	end
	return rsub(pron, "^" .. beginning, "")
end

-- Construct the pronunciation of all forms of an -er verb. PRONSTEM is the
-- pronunciation respelling of the stem (minus -er). If PRONSTEM_FINAL_FUT is
-- given, it is used in place of PRONSTEM for the forms without a pronounced
-- ending (i.e. 1s/2s/3s/3p present) and for the future and conditional; this
-- is used with two-stem verbs such as mener (with stems 'men' and 'mèn') and
-- céder (with stems 'céd' and 'cèd').
local function construct_er_pron(data, pronstem, pronstem_final_fut)
	pronstem_final_fut = pronstem_final_fut or pronstem
	pronstem = map(pronstem, function(stem) return data.pronstem .. stem end)
	pronstem_final_fut = map(pronstem_final_fut, function(stem)
		stem = data.pronstem .. stem
		-- In pronstem_final_fut, convert é+C in the last syllable to è even if
		-- the caller didn't do it. This is principally useful with pron=
		-- specifications, so that e.g. pron=blésser,blèsser works.
		stem = rsub(stem, "é(" .. written_cons_c .. "+)$", "è%1")
		return rsub(stem, "é([gq]u)$", "è%1")
	end)
	local stem_final = dopron(nil, pronstem_final_fut, "e")
	local stem_nonfinal = strip_pron_ending(dopron(nil, pronstem, "ez"), "e")
	local stem_nonfinal_i = strip_pron_ending(dopron(nil, pronstem, "iez"), "je")
	local stem_fut = strip_pron_ending(dopron(nil, pronstem_final_fut, "erez"), "e")
	local stem_fut_i = strip_pron_ending(dopron(nil, pronstem_final_fut, "eriez"), "je")
	return m_pron.er(data, stem_final, stem_nonfinal, stem_nonfinal_i,
		stem_fut, stem_fut_i)
end

-- Construct the conjugation and pronunciation of all forms of a non-er verb.
-- DATA holds the forms and pronunciations. The remaining args are stems:
--
-- * PRES_SG_STEM is used for pres indic/imper 1s/2s/3s;
-- * PRES_12P_STEM is used for pres indic/imper 1p/2p, the whole of the
--    imperfect, and the present participle;
-- * PRES_3P_STEM is used for pres indic 3p and the whole of the pres subj;
-- * PAST_STEM is used for the past historic and past participle;
-- * FUT_STEM (which should end with 'r') is used for the future and
--    conditional. If omitted, it is taken from the infinitive minus final -e.
-- * PP is the past participle. If omitted, if defaults to PAST_STEM.
-- * PRES_SUBJ_STEM if given overrides the present subjunctive stem.
-- * PRES_SUBJ_NONFINAL_STEM if given overrides the present subjunctive stem
--    specifically for 1p/2p, defaulting to PRES_SUBJ_STEM.
-- * ER_PRESENT, if true, specifies that the present singular follows an
--    -er type of conjugation (endings -e, -es, -e in place of -s, -s, -t).
--    In this case, PRES_12P_STEM and PRES_3P_STEM are currently ignored.
--    Normally, use construct_non_er_conj_er_present() in place of this arg.
--
-- Any of the stem arguments may actually be a table of stems.
local function construct_non_er_conj(data, pres_sg_stem, pres_12p_stem,
	pres_3p_stem, past_stem, fut_stem, pp, pres_subj_stem,
	pres_subj_nonfinal_stem, er_present)
	if er_present then
		m_core.make_ind_p_e(data, pres_sg_stem)
	else
		m_core.make_ind_p(data, pres_sg_stem, pres_12p_stem, pres_3p_stem)
	end
	m_core.make_ind_ps(data, past_stem)
	if not fut_stem then
		fut_stem = rsub(data.forms.inf, "e$", "")
	end
	m_core.make_ind_f(data, fut_stem)

	-- Most of the time it works to add 's' to produce the 1sg (it doesn't
	-- always work to use the stem directly, cf. apparais vs. apparai). But
	-- this fails with stems ending in -er, e.g 'resser-' from 'resservir',
	-- because the 'r' will be silent. In that case, we add 't' to produce
	-- the 3sg. We can't always add 't' because that will fail with e.g.
	-- 'ressen-' from 'ressentir', where the resulting '-ent' will be silent.
	if pres_sg_stem ~= "—" then
		if er_present then
			local stem_final_pron = dopron(data, pres_sg_stem, "e")
			local stem_nonfinal_pron = strip_pron_ending(dopron(data, pres_sg_stem, "ez"), "e")
			local stem_nonfinal_i_pron = strip_pron_ending(dopron(data, pres_sg_stem, "iez"), "je")
			m_pron.er(data, stem_final_pron, stem_nonfinal_pron,
				stem_nonfinal_i_pron)
		else
			local pres_sg_stem_pron = map(pres_sg_stem, function(stem)
				return rmatch(data.pronstem .. stem, "er$") and dopron(data, stem, "t") or dopron(data, stem, "s")
			end)
			local pres_12p_stem_pron = strip_pron_ending(dopron(data, pres_12p_stem, "ez"), "e")
			local pres_3p_stem_pron = dopron(data, pres_3p_stem, "e")
			local pre_j_stem_pron = strip_pron_ending(dopron(data, pres_12p_stem, "iez"), "je")
			m_pron.ind_p(data, pres_sg_stem_pron, pres_12p_stem_pron, pres_3p_stem_pron, pre_j_stem_pron)
		end
	end
	if past_stem ~= "—" then
		local past_stem_pron = dopron(data, past_stem)
		m_pron.ind_ps(data, past_stem_pron)
	end
	if fut_stem ~= "—" then
		local fut_stem_pron = strip_pron_ending(dopron(data, fut_stem, "ez"), "e")
		-- If the future stem ends in -er, the schwa is optional in -erez but
		-- not in -eriez; examples are assaillir, cueillir, refaire, défaire,
		-- contrefaire, méfaire (the latter four have the future pronounced
		-- -fer-). Also, if the future stem ends in -Cr, there will be an
		-- extra syllable inserted before -ions, -iez.
		local fut_stem_pron_i = strip_pron_ending(dopron(data, fut_stem, "iez"), "je")
		m_pron.ind_f(data, fut_stem_pron, fut_stem_pron_i)
	end

	if pp then
		data.forms.pp = pp
		if pp ~= "—" then
			data.prons.pp = dopron(data, pp)
		end
	end

	if pres_subj_stem then
		m_core.make_sub_p(data, pres_subj_stem, pres_subj_nonfinal_stem)
		if pres_subj_stem ~= "—" then
			local pres_subj_pron1 = dopron(data, pres_subj_stem, "e")
			local pres_subj_pron2 = strip_pron_ending(dopron(data, pres_subj_nonfinal_stem or pres_subj_stem, "iez"), "je")
			m_pron.sub_p(data, pres_subj_pron1, pres_subj_pron2)
		end
	end
end

-- Construct the conjugation and pronunciation of all forms of a non-er verb
-- with an -er type of present (singular -e, -es, -e). DATA holds the forms
-- and pronunciations. The remaining args are stems:
--
-- * PRES_STEM is used for the whole of the present as well as the imperfect
--    indicative;
-- * PAST_STEM is used for the past historic and past participle;
-- * FUT_STEM (which should end with 'r') is used for the future and
--    conditional. If omitted, it is taken from the infinitive minus final -e.
-- * PP is the past participle. If omitted, if defaults to PAST_STEM.
-- * PRES_SUBJ_STEM if given overrides the present subjunctive stem.
-- * PRES_SUBJ_NONFINAL_STEM if given overrides the present subjunctive stem
--    specifically for 1p/2p, defaulting to PRES_SUBJ_STEM.
--
-- Any of the stem arguments may actually be a table of stems.
local function construct_non_er_conj_er_present(data, pres_stem, past_stem,
	fut_stem, pp, pres_subj_stem, pres_subj_nonfinal_stem)
	-- Specify the pp explicitly, explicitly defaulting to the past_stem,
	-- else if will end in -é.
	construct_non_er_conj(data, pres_stem, nil, nil, past_stem, fut_stem,
	pp or past_stem, pres_subj_stem, pres_subj_nonfinal_stem, "er-present")
end

local function copy_ind_pron_to_imp(data)
	data.prons.imp_p_2s = data.prons.ind_p_2s
	data.prons.imp_p_1p = data.prons.ind_p_1p
	data.prons.imp_p_2p = data.prons.ind_p_2p
end

local function generate_imp_pron_from_forms(data)
	data.prons.imp_p_2s = dopron(data, data.forms.imp_p_2s)
	data.prons.imp_p_1p = dopron(data, data.forms.imp_p_1p)
	data.prons.imp_p_2p = dopron(data, data.forms.imp_p_2p)
end

local function impersonal_verb(data)
	for _, k in ipairs(all_verb_props) do
		if rmatch(k, "[12]") or rmatch(k, "3p") then
			data.forms[k] = "—"
		end
	end
end

local function only_third_verb(data)
	for _, k in ipairs(all_verb_props) do
		if rmatch(k, "[12]") then
			data.forms[k] = "—"
		end
	end
end

conj["er"] = function(data)
	if data.stem == "all" then
		data.stem = ""
		data.pronstem = strip_respelling_ending(data.pron, "aller") or data.stem
		conj["irreg-aller"](data)
		data.forms.inf = "aller"

		data.conjcat = "aller"
		data.cat = "suppletive"
	else
		m_core.make_ind_p_e(data, "")
		construct_er_pron(data, "")
		data.group = 1
		data.conjcat = "-er"
	end
end

conj["cer"] = function(data)
	m_core.make_ind_p_e(data, "c", "ç")

	data.notes = "この動詞は‘c’が母音‘a’及び‘o’の前で‘ç’となる" .. link("-er") .. "動詞である。"
	construct_er_pron(data, "c")
	data.group = 1
	data.conjcat = "-cer"
end

conj["ger"] = function(data)
	m_core.make_ind_p_e(data, "g", "ge")

	data.notes = "これは規則的な" .. link("-er") .. "動詞であるが、''-a-''や''-o-''で始まる活用語尾の前では語幹が''{stem}ge-''と書かれる"
	data.notes = data.notes .. "(''-g-'' is a “軟音”の" .. IPA("/ʒ/") .. "であり、“硬音”の" .. IPA("/ɡ/") .. "ではないことを示す)。"
	data.notes = data.notes .. "この綴りの変化は"
	data.notes = data.notes .. link(data.stem == "nei" and "bouger" or "neiger") .. "や"
	data.notes = data.notes .. link(data.stem == "man" and "ranger" or "manger") .. "のような''-ger''が付く全ての動詞で起こる。"

	construct_er_pron(data, "g")
	data.group = 1
	data.conjcat = "-ger"
end

conj["ayer"] = function(data)
	data.notes = "This is a regular " .. link("-er") .. " verb as far as "
		.. "pronunciation is concerned, but as with other verbs in ''-ayer'' "
		.. "(such as " .. link(data.stem == "pay" and "essayer" or "payer")
		.. " and " .. link((data.stem == "pay" or data.stem == "essay") and "balayer" or "essayer")
		.. ", the <y> of its stem may optionally be written as <i> "
		.. "when it precedes a silent <e> (compare verbs in ''-eyer'', "
		.. "which never have this spelling change, and verbs in ''-oyer'' "
		.. "and ''-uyer'', which always have it; verbs in ''-ayer'' belong to "
		.. "both groups, according to the writer's preference)."

	m_core.make_ind_p_e(data, {"ay", "ai"}, "ay", "ay")
	construct_er_pron(data, {"ay", "éy"}, {"ay", "ai"})
	data.group = 1
	data.conjcat = "-ayer"
end

conj["eyer"] = function(data)
	m_core.make_ind_p_e(data, "ey")
	construct_er_pron(data, {"ey", "éy"}, "ey")
	data.group = 1
	data.conjcat = "-eyer"
end

conj["yer"] = function(data)
	data.notes = "This verb is part of a large group of " .. link("-er")
		.. " verbs that conjugate like "
		.. link(data.stem == "no" and "employer" or "noyer") .. " or "
		.. link(data.stem == "ennu" and "appuyer" or "ennuyer") .. ". These "
		.. "verbs always replace the ‘y’ with an ‘i’ before a silent ‘e’."

	m_core.make_ind_p_e(data, "i", "y", "y")
	construct_er_pron(data, "y", "i")
	data.group = 1
	data.conjcat = "-yer"
end

conj["xxer"] = function(data)
	local newstem, consonant = rmatch(data.stem, "^(.*)e(" .. written_cons_c .. ")$")
	if not consonant then
		error("語幹 '" .. data.stem .. "' は -e- + 子音で終わるべきである")
	end
	data.forms.inf = "e" .. consonant .. "er" -- not xxer
	local origstem = data.stem
	data.stem = newstem
	data.pronstem = strip_respelling_ending(data.pron, data.forms.inf) or data.stem

	data.notes = "With the exception of " .. (origstem == "appel" and "''appeler''" or link("appeler")) .. ", "
	data.notes = data.notes .. (origstem == "jet" and "''jeter''" or link("jeter")) .. " and their derived verbs, "
	data.notes = data.notes .. "all verbs that used to double the consonants can also now be conjugated like " .. link("amener") .. "."

	if rfind(origstem, "jet$") or rfind(origstem, "appel$") then
		m_core.make_ind_p_e(data, "e" .. consonant .. consonant,
			"e" .. consonant, "e" .. consonant)
	else
		m_core.make_ind_p_e(data, {"e" .. consonant .. consonant, "è" .. consonant},
			"e" .. consonant, "e" .. consonant)
	end
	construct_er_pron(data, "e" .. consonant, "e" .. consonant .. consonant)
	data.group = 1
	data.conjcat = "-xxer"
end

conj["e-er"] = function(data)
	local newstem, consonant = rmatch(data.stem, "^(.*)e(" .. written_cons_c .. "+)$")
	if not consonant then
		error("語幹 '" .. data.stem .. "' は -e- + 一つ以上の子音で終わるべきである")
	end
	local stem = 'e' .. consonant
	local stem2 = 'è' .. consonant
	data.forms.inf = stem .. "er" -- not e-er
	local origstem = data.stem
	data.stem = newstem
	data.pronstem = strip_respelling_ending(data.pron, data.forms.inf) or data.stem

	data.notes = "This verb is conjugated mostly like the regular " .. link("-er") .. " verbs (" .. link("parler") .. " and " .. link("chanter") .. " and so on), "
	data.notes = data.notes .. "but the ''-e-'' " .. IPA("/ə/") .. " of the second-to-last syllable becomes ''-è-'' " .. IPA("/ɛ/") .. " when the next vowel is a silent or schwa ''-e-''. "
	data.notes = data.notes .. "For example, in the third-person singular present indicative, we have ''il {stem}" .. stem2 .. "e'' rather than *''il {stem}" .. stem .. "e''. "
	data.notes = data.notes .. "Other verbs conjugated this way include " .. link(origstem == "lev" and "acheter" or "lever") .. " and " .. link(origstem == "men" and "acheter" or "mener") .. ". "
	data.notes = data.notes .. "Related but distinct conjugations include those of " .. link("appeler") .. " and " .. link("préférer") .. "."

	m_core.make_ind_p_e(data, stem2, stem, stem)
	construct_er_pron(data, stem, stem2)
	data.group = 1
	data.conjcat = "-e-er"
end

conj["ecer"] = function(data)
	m_core.make_ind_p_e(data, "èc", "eç", "ec")
	construct_er_pron(data, "ec", "èc")
	data.group = 1
	data.conjcat = "-e-er"
end

conj["eger"] = function(data)
	m_core.make_ind_p_e(data, "èg", "ege", "eg")
	construct_er_pron(data, "eg", "èg")
	data.group = 1
	data.conjcat = "-e-er"
end

conj["é-er"] = function(data)
	local newstem, consonant = rmatch(data.stem, "^(.*)é(" .. written_cons_c .. "+)$")
	if not consonant then
		newstem, consonant = rmatch(data.stem, "^(.*)é([gq]u)$")
	end
	if not consonant then
		error("Stem '" .. data.stem .. "' should end with -e- + one or more consonants")
	end
	local stem = 'é' .. consonant
	local stem2 = 'è' .. consonant
	data.forms.inf = stem .. "er" -- not é-er
	local origstem = data.stem
	data.stem = newstem
	data.pronstem = strip_respelling_ending(data.pron, data.forms.inf) or data.stem

	data.notes = "This verb is conjugated like "
	if origstem == "céd" then
		data.notes = data.notes .. link("espérer")
	else
		data.notes = data.notes .. link("céder")
	end
	data.notes = data.notes .. ". It is a regular " .. link("-er") .. " verb, "
	data.notes = data.notes .. "except that its last stem vowel alternates between " .. IPA("/e/") .. " (written ‘é’) and "
	data.notes = data.notes .. IPA("/ɛ/") .. " (written ‘è’), with the latter being used before mute ‘e’.\n"
	data.notes = data.notes .. "One special case is the future stem, used in the future and the conditional. "
	data.notes = data.notes .. "Before 1990, the future stem of such verbs was written ''{stem}" .. stem .. "er-'', "
	data.notes = data.notes .. "reflecting the historic pronunciation " .. IPA("/e/") .. ". "
	data.notes = data.notes .. "In 1990, the French Academy recommended that it be written ''{stem}" .. stem2 .. "er-'', "
	data.notes = data.notes .. "reflecting the now common pronunciation " .. IPA("/ɛ/") .. ", "
	data.notes = data.notes .. "thereby making this distinction consistent throughout the conjugation "
	data.notes = data.notes .. "(and also matching in this regard the conjugations of verbs like " .. link("lever") .. " and " .. link("jeter") .. "). "
	data.notes = data.notes .. "Both spellings are in use today, and both are therefore given here."

	m_core.make_ind_p_e(data, stem2, stem, stem)
	m_core.make_ind_f(data, {stem2 .. "er", stem .. "er"})
	construct_er_pron(data, stem, stem2)
	data.group = 1
	data.conjcat = "-é-er"
end

conj["écer"] = function(data)
	data.notes = "This verb is conjugated like " .. link("rapiécer") .. ". It has both the spelling irregularities of other verbs in ''<span lang=\"fr\">-cer</span>'' "
	data.notes = data.notes .. "(such as " .. link("pincer") .. ", where a silent ‘e’ is inserted before ‘a’ and ‘o’ endings (to indicate the " .. IPA("/s/") .. " sound), "
	data.notes = data.notes .. "and the spelling and pronunciation irregularities of other verbs in ''<span lang=\"fr\">-é-er</span>'' (such as " .. link("céder") .. ", "
	data.notes = data.notes .. "where the last stem vowel alternates between " .. IPA("/e/") .. " (written ‘é’) and " .. IPA("/ɛ/") .. " (written ‘è’)."

	m_core.make_ind_p_e(data, "èc", "éç", "éc")
	m_core.make_ind_f(data, {"écer", "ècer"})
	construct_er_pron(data, "éc", "èc")
	data.group = 1
	data.conjcat = "-é-er"
end

conj["éger"] = function(data)
	data.notes = "This verb is conjugated like "
	if data.stem == "prot" then
		data.notes = data.notes .. link("assiéger")
	else
		data.notes = data.notes .. link("protéger")
	end
	data.notes = data.notes .. ". It has both the spelling irregularities of other verbs in ''-ger'' (such as " .. link("manger") .. ", "
	data.notes = data.notes .. "where a silent ‘e’ is inserted before ‘a’ and ‘o’ endings (to indicate the " .. IPA("/ʒ/") .. " sound), "
	data.notes = data.notes .. "and the spelling and pronunciation irregularities of other verbs in ''-é-er'' (such as " .. link("céder") .. "), "
	data.notes = data.notes .. "where the last stem vowel alternates between " .. IPA("/e/") .. " (written ‘é’) and " .. IPA("/ɛ/") .. " (written ‘è’)."

	m_core.make_ind_p_e(data, "èg", "ége", "ég")
	m_core.make_ind_f(data, {"éger", "èger"})
	construct_er_pron(data, "ég", "èg")
	data.group = 1
	data.conjcat = "-é-er"
end

conj["ir-s"] = function(data)
	local ending = usub(data.stem, -1, -1)
	data.stem = usub(data.stem, 1, -2)
	data.pronstem = strip_respelling_ending(data.pron, ending .. "ir") or data.stem

	data.notes = "This is one of a fairly large group of irregular " .. link("-ir") .. " verbs that are all conjugated the same way. "
	data.notes = data.notes .. "Other members of this group include "
	if data.stem..ending.."ir" == "sortir" then
		data.notes = data.notes .. link("partir")
	else
		data.notes = data.notes .. link("sortir")
	end
	data.notes = data.notes .. " and "
	if data.stem..ending.."ir" == "dormir" then
		data.notes = data.notes .. link("servir")
	else
		data.notes = data.notes .. link("dormir")
	end
	data.notes = data.notes .. ". The most significant difference between these verbs' conjugation and that of the regular ''-ir'' verbs is that "
	data.notes = data.notes .. "these verbs' conjugation does not use the infix " .. link("-iss-") .. ". "
	data.notes = data.notes .. "Further, this conjugation has the forms " .. link("{stem}s", "(je, tu) {stem}s") .. " and " .. link("{stem}t", "(il) {stem}t") .. " "
	data.notes = data.notes .. "in the present indicative and imperative, whereas a regular ''-ir'' verb would have ''*{stem}" .. ending .. "is'' and ''*{stem}" .. ending .. "it'' (as in the past historic)."

	data.forms.inf = ending .. "ir"
	construct_non_er_conj(data, "", ending, ending, ending .. "i")
	data.conjcat = "-ir"
end

conj["ir-reg"] = function(data)
	-- if ir-reg explicitly used in type argument (e.g. ressortir), inf will
	-- be ir-reg by default with messed-up future
	data.forms.inf = "ir"
	construct_non_er_conj(data, "i", "iss", "iss", "i")
	data.notes = "これは"
		.. (data.stem == "fin" and "nourrir" or "finir") .. ", "
		.. (data.stem == "chois" and "nourrir" or "choisir")
		.. "のような第二群動詞の規則動詞であり、不定詞が" .. link("-ir")
		.. "で終わる。この活用の顕著な特徴は"
		.. "接中辞" .. link("-iss-") .. "が繰り返し現れることである。"
	data.group = 2
	data.conjcat = "-ir"
end

conj["ir"] = function(data)
	if ir_s[data.stem.."ir"] then
		conj["ir-s"](data)
	else
		conj["ir-reg"](data)
	end
end

conj["ïr"] = function(data)
	construct_non_er_conj(data, "ï", "ïss", "ïss", "ï")
	data.group = 2
	data.conjcat = "-ïr"
end

conj["haïr"] = function(data)
	data.notes = "This verb is spelled as if conjugated like " .. link("finir") .. ", but has a [[diaeresis]] throughout its conjugation "
	data.notes = data.notes .. "(including where the circumflex would normally be used) except in the singular indicative present, "
	data.notes = data.notes .. "whose forms are pronounced " .. IPA("/ɛ/") .. " in Standard French instead of " .. IPA("/ai/") .. ", "
	data.notes = data.notes .. "a pronunciation nonetheless often found in informal speech."

	construct_non_er_conj(data, "hai", "haïss", "haïss", "haï")
	data.conjcat = "haïr"
end

conj["ouïr"] = function(data)
	data.notes = "The forms beginning with ''oi-'', ''oy-'', or ''orr-'' are archaic."

	construct_non_er_conj(data, {"ouï", "oi"}, {"ouïss", "oy"},
		{"ouïss", "oi"}, "ouï", {"ouïr", "oir", "orr"})
	-- Need to override the pronunciations of all forms in oy-.
	data.prons.ind_p_1p = dopron(data, {"ouïssons", "oillons"})
	data.prons.ind_p_2p = dopron(data, {"ouïssez", "oillez"})
	copy_ind_pron_to_imp(data)
	m_pron.ind_i(data, strip_pron_ending(dopron(data, {"ouïssez", "oillez"}), "e"))
	m_pron.sub_p(data, dopron(data, {"ouïsse", "oie"}), strip_pron_ending(
		dopron(data, {"ouïssiez", "oilliez"}), "je"))
	data.prons.ppr = dopron(data, {"ouïssant", "oillant"})
	data.conjcat = "ouïr"
end

conj["asseoir"] = function(data)
	data.notes = "The verb " .. link("asseoir") .. " (and its derivative " .. link("rasseoir") .. ") has 2 distinct conjugations."

	construct_non_er_conj(data, {"assoi", "assied"}, {"assoy", "assey"},
		{"assoi", "assey"}, "assi", {"assoir", "assiér"}, "assis")
	data.conjcat = "seoir"
end

conj["surseoir"] = function(data)
	construct_non_er_conj(data, "sursoi", "sursoy", "sursoi", "sursi", nil,
		"sursis")
	-- Pronunciation in future/cond as if written sursoir- not surseoir-
	m_pron.ind_f(data, strip_pron_ending(dopron(data, "sursoirez"), "e"))
	data.conjcat = "seoir"
end

conj["seoir"] = function(data)
	data.notes = "これは第三人称でのみ活用する欠如動詞である。"

	construct_non_er_conj(data, "sied", "sey", "sié", "—", "siér")
	only_third_verb(data)
	setform(data, "ppr", {"séant","seyant"})
	data.conjcat = "seoir"
	data.cat = "欠如"
end

conj["bouillir"] = function(data)
	construct_non_er_conj(data, "bou", "bouill", "bouill", "bouilli")
	data.conjcat = "bouillir"
end

conj["enir"] = function(data)
	construct_non_er_conj(data, "ien", "en", "ienn", "in", "iendr", "enu")

	if usub(data.stem,-1) == "t" then
		data.notes = "この動詞は" .. link("-ir")
			.. "動詞で、"
			.. link(data.stem == "cont" and "retenir" or "contenir")
			.. "や" .. link(data.stem == "dét" and "retenir" or "détenir")
			.. "のように''-tenir''で終わる動詞は全てこのように活用する。"
		data.conjcat = "tenir"
	else
		data.notes = "この動詞は" .. link("-ir")
			.. "動詞で、"
			.. link(data.stem == "conv" and "revenir" or "convenir")
			.. "や" .. link(data.stem == "dev" and "revenir" or "devenir")
			.. "のように''-venir''で終わる動詞は全てこのように活用する。"
		data.conjcat = "venir"
	end
end

local function ouvrir_ffrir(data, rir_prefix)
	data.stem = data.stem .. rir_prefix
	data.pronstem = data.pronstem .. rir_prefix
	data.forms.inf = "rir"

	data.notes = "この動詞は" .. link(data.stem == "ouv" and "couvrir" or "ouvrir")
		.. "や" .. link(data.stem == "off" and "souffrir" or "offrir") .. "のように活用する。"
		.. "これは直説法現在、直説法半過去、接続法現在、命令法及び現在分詞で規則動詞の" .. link("-er") .. "動詞のように活用するが、"
		.. "不定詞、単純未来、条件法、単純過去及び接続法半過去では規則動詞の" .. link("-ir") .. "動詞のように活用し、"
		.. "過去分詞" .. link("{stem}ert") .. "は不規則である。"

	construct_non_er_conj_er_present(data, "r", "ri", nil, "ert")
end

conj["ouvrir"] = function(data)
	ouvrir_ffrir(data, "ouv")
end

conj["ffrir"] = function(data)
	ouvrir_ffrir(data, "ff")
end

conj["quérir"] = function(data)
	construct_non_er_conj(data, "quier", "quér", "quièr", "qui", "querr", "quis")
end

conj["aillir"] = function(data)
	data.notes = "This verb is part of a small group of verbs in "
	.. link("-ir") .. " that conjugate in the indicative imperfect and "
	.. "present, the subjunctive present, and the present participle, as if "
	.. "they ended in " .. link("-er") .. ". They are sometimes written with "
	.. "an ‘e’ in the future and imperfect, like " .. link("cueillir")
	.. " and other verbs in ''-llir''."
	construct_non_er_conj_er_present(data, "aill", "ailli", {"aillir", "ailler"})
end

conj["chauvir"] = function(data)
	data.notes = "The forms without -iss- are recommended by the [[w:Académie française|French Academy]], although their usage is not common."

	construct_non_er_conj(data, "chauvi", {"chauv", "chauviss"},
		{"chauv", "chauviss"}, "chauvi")
	data.group = {2, 3}
end

conj["choir"] = function(data)
	construct_non_er_conj(data, "choi", "choy", "choi", "chu",
		data.stem == "é" and "choir" or {"choir", "cherr"})
	m_core.clear_imp(data)
	data.forms.ppr = "—"

	if data.stem == "" then
		data.notes = "これは[[欠如動詞]]で、特定特定の時制でのみ活用する。"
		-- FIXME! frwikt says 1p 2p of pres indic is rare, and likewise
		-- all of the pres subj.
		m_core.make_ind_i(data, "—")
		-- FIXME! frwikt says future in cherr- is archaic, and archaic
		-- conditional forms in cherr- exist as well.
		m_core.make_cond_p(data, "choir")
		m_pron.cond_p(data, dopron(data, "choir"))
		m_core.make_sub_p(data, "—")
		-- FIXME! frwikt does not say subjunctive past is missing other than
		-- 3s.
		m_core.make_sub_pa(data, "—")
		data.forms.sub_pa_3s = "chût"
	elseif data.stem == "dé" then
		data.notes = "これは直説法半過去、命令法及び現在分詞を持たない[[欠如動詞]]である。"
		m_core.make_ind_i(data, "—")
		-- FIXME! frwikt does not indicate 'chet' as an alternative. Based on
		-- échoir, we'd expect 'chettent' as alternative as well.
		setform(data, "ind_p_3s", {"choit", "chet"})
		-- FIXME! frwikt lists rare ppr déchoyant.
	elseif data.stem == "é" then
		data.notes = "これは第三人称でのみ活用する[[欠如動詞]]である。"
		only_third_verb(data)
		setform(data, "ind_p_3s", {"choit", "chet"})
		-- FIXME! frwikt gives both échettent and échéent as alternatives,
		-- but gives the pronunciation only of the first.
		setform(data, "ind_p_3p", {"choient", "chettent"})
		setform(data, "ppr", "chéant")
	end
	data.cat = "欠如"
end

conj["cueillir"] = function(data)
	construct_non_er_conj_er_present(data, "cueill", "cueilli", {"cueillir", "cueiller"})
end

conj["courir"] = function(data)
	data.notes = "この動詞は条件法現在及び及び未来形の語幹の最後に‘r’が加えられ、"
	data.notes = data.notes .. "過去分詞が''-u'' で終わることを除いて" .. link("-ir") .. " 動詞の規則動詞のように活用する。"
	data.notes = data.notes .. "''-courir'' で終わる全ての動詞もこのように活用する。"

	construct_non_er_conj(data, "cour", "cour", "cour", "couru", "courr")
end

conj["falloir"] = function(data)
	data.notes = "これは第三人称単数形でのみ活用する[[欠如動詞]]である。"
	construct_non_er_conj(data, "fau", "fall", "fall", "fallu", "faudr", nil,
		"faill")
	impersonal_verb(data)
	data.cat = {"欠如", "非人称"}
end

conj["faillir"] = function(data)
	if data.stem == "" then
		data.notes = "This verb has two conjugations, one is older and irregular, "
			.. "but is in modern usage giving way to a conjugation like that of "
			.. link("finir") .. ". It is hardly used except in the infinitive, "
			.. "past historic, and the composed tenses. The third-person singular "
			.. "present indicative " .. link("faut") .. " is also found in "
			.. "certain set phrases."
		construct_non_er_conj(data, "fau", "faill", "faill", "failli",
			{"faudr", "faillir"})
		data.forms.ind_p_1s = "faux"
		data.forms.ind_p_2s = "faux"
		m_core.clear_imp(data)
		data.cat = "欠如"
	else
		data.notes = "Verbs in ''-faillir'', with the exception of "
		.. link("faillir") .. " itself, conjugate similarly to other verbs in "
		.. "''-illir'', such as " .. link("assaillir") .. " and "
		.. link("cueillir") .. "."
		-- frwikt doesn't include forms like -faillerai
		construct_non_er_conj_er_present(data, "faill", "failli", "faillir")
	end
end

conj["férir"] = function(data)
	data.notes = "This verb is defective and is virtually never conjugated in Modern French, except in a few set phrases or as a mark of extreme archaism. "
	data.notes = data.notes .. "Most of its uses stem from variations on " .. link("sans coup férir") .. "."

	construct_non_er_conj(data, "—", "—", "—", "—", "—", "féru")
	data.cat = "defective"
end

conj["fuir"] = function(data)
	construct_non_er_conj(data, "fui", "fuy", "fui", "fui")
end

conj["gésir"] = function(data)
	data.notes = "これは現在形と直説法半過去でのみ活用する[[欠如動詞]]である。"
	construct_non_er_conj(data, "gi", "gis", "gis", "—", "—", "—", "—")
	data.forms.ind_p_3s = "gît"
	m_core.clear_imp(data)
	data.cat = "欠如"
end

conj["re"] = function(data)
	construct_non_er_conj(data, "", "", "", "i", nil, "u")
	data.forms.ind_p_3s = ""
	data.irregular = "no"
end

conj["cre"] = function(data)
	data.notes = "This verb "
	if data.stem ~= "vain" then
		data.notes = data.notes .. "is conjugated like " .. link("vaincre") .. ". That means it "
	end
	data.notes = data.notes .. "is conjugated like " .. link("vendre") .. ", except that its usual stem ''{stem}qu-'' becomes ''{stem}c-'' when either there is no ending, "
	data.notes = data.notes .. "or the ending starts with ''-u-'' or a written consonant. "
	data.notes = data.notes .. "Additionally, when inverted the third person singular in the present adds the infix " .. link("t","-t-") .. ": ''{stem}c-t-il?'' "
	data.notes = data.notes .. "These are strictly spelling changes; pronunciation-wise, the verb is conjugated exactly like " .. link("vendre") .. "."

	construct_non_er_conj(data, "c", "qu", "qu", "qui", nil, "cu")
end

conj["pre"] = function(data)
	data.notes = "This verb "
	if data.stem ~= "rom" then
		data.notes = data.notes .. "is conjugated like " .. link("rompre") .. ". That means it "
	end
	data.notes = data.notes .. "is conjugated like " .. link("vendre") .. ", except that it adds an extra ''-t'' in the third-person singular form of the present indicative: ''il " .. link(data.stem .. "pt") .. "'', not ''*il {stem}p''. "
	data.notes = data.notes .. "This is strictly a spelling change; pronunciation-wise, the verb is conjugated exactly like " .. link("vendre") .. "."

	construct_non_er_conj(data, "p", "p", "p", "pi", nil, "pu")
end

conj["crire"] = function(data)
	construct_non_er_conj(data, "cri", "criv", "criv", "crivi", nil, "crit")
end

conj["rire"] = function(data)
	construct_non_er_conj(data, "ri", "ri", "ri", "ri")
end

conj["uire"] = function(data)
	construct_non_er_conj(data, "ui", "uis", "uis", "uisi", nil, "uit")
end

conj["nuire"] = function(data)
	-- nuire has different pp from other -uire verbs
	construct_non_er_conj(data, "nui", "nuis", "nuis", "nuisi", nil, "nui")
end

conj["aitre"] = function(data)
	data.notes = "This verb is one of a fairly small group of " .. link("-re") .. " verbs, that are all conjugated the same way. They are conjugated the same as the alternative spelling, which has a [[circumflex]] over the ‘i’, except that the circumflex is dropped here."

	-- future stem must be nil here because we are called from conj["aître"]
	construct_non_er_conj(data, "ai", "aiss", "aiss", "u", nil, "u")
end

conj["aître"] = function(data)
	conj["aitre"](data)
	data.notes = "This verb is one of a fairly small group of " .. link("-re") .. " verbs, that are all conjugated the same way. They are unlike other verb groups in that the ‘i’ is given a circumflex before a ‘t’."
	data.forms.ind_p_3s = "aît"
end

conj["oître"] = function(data)
	data.notes = "This verb is one of a fairly small group of " .. link("-re") .. " verbs, that are all conjugated the same way. They are unlike other verb groups in that the ‘i’ is given a circumflex before a ‘t’. This conjugation pattern is no longer in use and has been replaced by -aître."

	m_core.make_ind_p(data, "oi", "oiss")
	data.forms.ind_p_3s = "oît"
	m_core.make_ind_ps(data, "u")

	local stem = dopron(data, "ais")
	local stem2 = stem .. ".s"
	local stem3 = stem .. "s"
	local stem4 = dopron(data, "u")

	m_pron.ind_p(data, stem, stem2, stem3)
	m_pron.ind_ps(data, stem4)
	m_pron.ind_f(data, stem .. ".tʁ", stem .. ".tʁi.")
end

conj["indre"] = function(data)
	data.notes = "この動詞は"
		.. link(data.stem == "pei" and "plaindre" or "peindre")
		.. "のように活用する。" .. link("rendre") .. "や"
		.. link("vendre") .. "と同じ活用語尾を用いるが、母音の前では''-nd-''が''-gn-''に変わり、"
		.. "過去分詞は母音の代わりに‘t’で終わる。"
	construct_non_er_conj(data, "in", "ign", "ign", "igni", nil, "int")
end

conj["clure"] = function(data)
	local pp
	if data.stem == "in" or data.stem == "trans" or data.stem == "oc" then
		pp = "clus"
		data.notes = "This verb is one of a few verbs in ''-clure'' where the past participle is in ''-us(e)'' instead of ''-u(e)''."
	end

	construct_non_er_conj(data, "clu", "clu", "clu", "clu", nil, pp)
end

conj["raire"] = function(data) --braire, traire
	data.notes = "This verb traditionally has no past historic or imperfect "
		.. "subjunctive. They would be formed on a -{stem}ray- root: "
		.. "*je {stem}rayis, *que nous {stem}rayissions etc. Forms using "
		.. "the ‘a’ endings of verbs in -er are now used when there is an "
		.. "unavoidable need to use these forms.\n"
		.. "The root -{stem}rais- was used instead of -{stem}ray- in the "
		.. "18th century, and remains in Swiss and Savoy dialects."
	m_core.make_ind_p(data, "rai", "ray", "rai")
	m_core.make_ind_ps_a(data, "ray")

	local stem = dopron(data, "rais")
	data.forms.pp = "rait"

	local stem2 = stem .. ".j"
	local stem3 = stem .. ".ʁ"

	m_pron.ind_p(data, stem, stem2)
	m_pron.ind_ps_a(data, stem2)
	m_pron.ind_f(data, stem3)
	data.prons.pp = stem
end

conj["clore"] = function(data)
	data.notes = "この動詞は特定の時制では活用しない。"

	m_core.make_ind_p(data, "clo", "clos")
	data.forms.ind_p_3s = "clôt"
	m_core.make_ind_i(data, "—")
	m_core.make_ind_ps(data, "—")
	data.forms.ppr = "closant"
	data.forms.pp = "clos"

	local stem = dopron(data, "clo")
	local stem2 = stem .. ".z"
	local stem3 = stem .. "z"
	local stem4 = dopron(data, "clɔ") .. ".ʁ"

	m_pron.ind_p(data, stem, stem2, stem3)
	m_pron.ind_f(data, stem4)
	data.prons.pp = stem
	data.cat = "欠如"
end

conj["confire"] = function(data)
	construct_non_er_conj(data, "confi", "confis", "confis", "confi", nil, "confit")
end

conj["suffire"] = function(data)
	construct_non_er_conj(data, "suffi", "suffis", "suffis", "suffi")
end

conj["coudre"] = function(data)
	data.notes = "This verb "
	if data.stem ~= "" then
		data.notes = data.notes .. "is conjugated like " .. link("coudre") .. ". That means it"
	end
	data.notes = data.notes .. " is conjugated like " .. link("rendre") .. ", except that its stem is ''{stem}coud-'' in only part of the conjugation. "
	data.notes = data.notes .. "Before endings that begin with vowels, the stem ''{stem}cous-'' (with a " .. IPA("/-z-/") .. " sound) is used instead; "
	data.notes = data.notes .. "for example, ''nous'' " .. link("{stem}cousons") .. ", not ''*nous {stem}coudons''."

	construct_non_er_conj(data, "coud", "cous", "cous", "cousi", nil, "cousu")
end

conj["croire"] = function(data)
	construct_non_er_conj(data, "croi", "croy", "croi", "cru")
end

conj["croitre"] = function(data)
	if data.stem == "" then
		data.notes = "This verb takes an especially irregular conjugation, taking circumflexes in many forms, so as to distinguish from the forms of the verb " .. link("croire") .. "."
		construct_non_er_conj(data, "croî", "croiss", "croiss", "crû")
		data.forms.ind_ps_1p = "crûmes"
		data.forms.ind_ps_2p = "crûtes"
		data.forms.sub_pa_3s = "crût"
	else
		data.notes = "This verb is conjugated like " .. link("croitre") ..
			" except that it does not take circumflexes like that verb does."
		construct_non_er_conj(data, "croi", "croiss", "croiss", "cru")
	end
end

conj["croître"] = function(data)
	if data.stem == "" then
		data.notes = "This verb takes an especially irregular conjugation, taking circumflexes in many forms, so as to distinguish from the forms of the verb " .. link("croire") .. "."
		construct_non_er_conj(data, "croî", "croiss", "croiss", "crû")
	else
		data.notes = "This verb is conjugated like " .. link("croître") ..
			" except that it takes fewer circumflexes than that verb does."
		construct_non_er_conj(data, "croi", "croiss", "croiss", "crû")
		data.forms.ind_p_3s = "croît"
	end
	data.forms.ind_ps_1p = "crûmes"
	data.forms.ind_ps_2p = "crûtes"
	data.forms.sub_pa_3s = "crût"
end

conj["foutre"] = function(data)
	construct_non_er_conj(data, "fou", "fout", "fout", "fouti", nil,
		"foutu")
end

conj["soudre"] = function(data)
	construct_non_er_conj(data, "sou", "solv", "solv", "solu", nil, "sous")
	m_core.make_sub_pa(data, "—")
	data.cat = "defective"
end

conj["résoudre"] = function(data)
	data.notes = "This verb also has a rare past participle "
		.. link("résous") .. " (feminine " .. link("résoute") .. ")."
	construct_non_er_conj(data, "résou", "résolv", "résolv", "résolu")
end

conj["voir"] = function(data)
	data.notes = "Verbs derived from " .. link("voir") .. " form their "
		.. "future and conditional forms using the root ''verr-'' instead of "
		.. "the ''vr-'' or ''voir-'' of other verbs."
	construct_non_er_conj(data, "voi", "voy", "voi", "vi", "verr", "vu")
end

conj["prévoir"] = function(data)
	construct_non_er_conj(data, "prévoi", "prévoy", "prévoi", "prévi", nil,
		"prévu")
end

conj["cevoir"] = function(data)
	construct_non_er_conj(data, "çoi", "cev", "çoiv", "çu", "cevr")
end

conj["battre"] = function(data)
	if data.stem ~= "" then
		data.notes = "This verb is conjugated like " .. link("battre") .. ". That means it "
	else
		data.notes = "This verb "
	end
	data.notes = data.notes .. "is conjugated like " .. link("vendre") .. ", " .. link("perdre") .. ", etc. (sometimes called the regular " .. link("-re") .. " verbs), "
	data.notes = data.notes .. "except that instead of *''{stem}batt'' and *''{stem}batts'', "
	data.notes = data.notes .. "it has the forms " .. link("{stem}bat") .. " and " .. link("{stem}bats") .. ". This is strictly a spelling change; "
	data.notes = data.notes .. "pronunciation-wise, the verb is conjugated exactly like " .. link("vendre") .. "."

	construct_non_er_conj(data, "bat", "batt", "batt", "batti", nil, "battu")
end

conj["circoncire"] = function(data)
	construct_non_er_conj(data, "circonci", "circoncis", "circoncis",
		"circonci", nil, "circoncis")
end

conj["lire"] = function(data)
	construct_non_er_conj(data, "li", "lis", "lis", "lu")
end

conj["luire"] = function(data)
	construct_non_er_conj(data, "lui", "luis", "luis", {"lui", "luisi"},
		nil, "lui")
	m_core.make_sub_pa(data, "luisi")
	m_pron.sub_pa(data, dopron(data, "luisi"))
	setform(data, "ind_ps_3s", "luit")
end

conj["maudire"] = function(data)
	data.notes = "This is ''almost'' a regular verb of the second conjugation, like " .. link("finir") .. ", " .. link("choisir") .. ", "
	data.notes = data.notes .. "and most other verbs with infinitives ending in " .. link("-ir") .. ". Its only irregularities are in the past participle, "
	data.notes = data.notes .. "which is " .. link("maudit","maudit(e)(s)") .. " rather than *''maudi(e)(s)'', and in the infinitive, "
	data.notes = data.notes .. "which is ''maudire'' rather than *''maudir''."

	construct_non_er_conj(data, "maudi", "maudiss", "maudiss", "maudi",
		nil, "maudit")
end

conj["mettre"] = function(data)
	if data.stem ~= "" then
		data.notes = "この動詞は" .. link("mettre") .. "のように活用する。つまり"
	else
		data.notes = "この動詞は"
	end
	data.notes = data.notes .. "過去分詞が*''{stem}mettu'' ではなく" .. link("{stem}mis") .. "、"
	data.notes = data.notes .. "単純過去と接続法半過去が*''{stem}metti-'' ではなく''{stem}mi-'' から"
	data.notes = data.notes .. "成る以外は" .. link("battre") .. " のように活用する。"

	construct_non_er_conj(data, "met", "mett", "mett", "mi", nil, "mis")
end

conj["moudre"] = function(data)
	construct_non_er_conj(data, "moud", "moul", "moul", "moulu")
end

conj["mouvoir"] = function(data)
	construct_non_er_conj(data, "meu", "mouv", "meuv", "mu", "mouvr")
	if data.stem == "" then
		data.forms.pp = "mû"
	end
end

conj["paitre"] = function(data)
	data.notes = "この動詞は特定の時制では活用しない。"
	construct_non_er_conj(data, "pai", "paiss", "paiss", "—")
	data.cat = "欠如"
end

conj["paître"] = function(data)
	conj["paitre"](data)
	data.forms.ind_p_3s = "paît"
end

conj["pleuvoir"] = function(data)
	data.notes = "この動詞は[[欠如動詞]]で"
	if data.stem == "re" then
		data.notes = data.notes .. "第三人称単数形でのみ活用する。"
	else
		data.notes = data.notes .. "第三人称でのみ活用する。第三人称複数形は比喩でのみ用いる。"
	end

	construct_non_er_conj(data, "pleu", "pleuv", "pleuv", "plu", "pleuvr")
	if data.stem == "re" then
		impersonal_verb(data)
		data.cat = {"欠如", "非人称"}
	else
		only_third_verb(data)
		data.cat = "欠如"
	end
end

conj["pourvoir"] = function(data)
	data.notes = "''Pourvoir''とこれに派生する動詞は単純過去と接続法半過去が''-vi-''の代わりに''-vu-''であるのを除いて" .. link("voir") .. "のように活用する。"

	construct_non_er_conj(data, "pourvoi", "pourvoy", "pourvoi", "pourvu")
end

conj["prendre"] = function(data)
	if data.stem ~= "" then
		data.notes = "This verb is conjugated on the model of " .. link("prendre") .. ". That means it is quite irregular, with the following patterns:\n"
	else
		data.notes = "This verb is quite irregular, with the following patterns:\n"
	end
	data.notes = data.notes .. "*In the infinitive, in the singular forms of the present indicative, and in the future and the conditional, it is conjugated like " .. link("rendre") .. ", " .. link("perdre") .. ", etc. (sometimes called the regular " .. link("-re") .. " verbs).\n"
	data.notes = data.notes .. "*In the plural forms of the present indicative and imperative, in the imperfect indicative, in the present subjunctive, and in the present participle, it is conjugated like " .. link("appeler") .. " or " .. link("jeter") .. ", using the stem ''{stem}prenn-'' before mute ‘e’ and the stem ''{stem}pren-'' elsewhere.\n"
	data.notes = data.notes .. "*In the past participle, and in the past historic and the imperfect subjunctive, its conjugation resembles that of " .. link("mettre") .. "."

	construct_non_er_conj(data, "prend", "pren", "prenn", "pri", nil, "pris")
end

conj["faire"] = function(data)
	construct_non_er_conj(data, "fai", "fais", "fais", "fi", "fer", "fait",
		"fass")
	-- Need to override the present indicative 2p and 3p, the imperative 2p,
	-- and the pronunciations of these forms as well as all forms in fais-.
	setform(data, "ind_p_2p", "faites")
	setform(data, "ind_p_3p", "font")
	data.prons.ind_p_1p = dopron(data, "fesons")
	data.forms.imp_p_2p = "faites"
	copy_ind_pron_to_imp(data)
	m_pron.ind_i(data, strip_pron_ending(dopron(data, "fesez"), "e"))
	data.prons.ppr = dopron(data, "fesant")
end

conj["boire"] = function(data)
	construct_non_er_conj(data, "boi", "buv", "boiv", "bu")
end

conj["devoir"] = function(data)
	construct_non_er_conj(data, "doi", "dev", "doiv", "du", "devr")
	if data.stem == "" then
		data.forms.pp = "dû"
	end
end

conj["avoir"] = function(data)
	m_core.make_ind_p(data, "a", "av")
	data.forms.ind_p_1s = "ai"
	data.forms.ind_p_3s = "a"
	data.forms.ind_p_3p = "ont"
	m_core.make_ind_ps(data, "eu")
	m_core.make_ind_f(data, "aur")
	m_core.make_sub_p(data, "ai")
	data.forms.sub_p_3s = "ait"
	data.forms.sub_p_1p = "ayons"
	data.forms.sub_p_2p = "ayez"
	m_core.make_imp_p_sub(data)
	data.forms.ppr = "ayant"

	local root = rsub(dopron(data, "a"),"a$","")

	local stem = root .. "a"
	local stem2 = root .. "a.v"
	local stem3 = root .. "y"
	local stem4 = root .. "o.ʁ"
	local stem5 = root .. "ɛ"
	local stem6 = root .. "ɛ."

	m_pron.ind_p(data, stem, stem2)
	data.prons.ind_p_1s = root .. "e"
	data.prons.ind_p_3p = root .. "ɔ̃"
	m_pron.ind_ps(data, stem3)
	m_pron.ind_f(data, stem4)
	m_pron.sub_p(data, stem5, stem6)
	generate_imp_pron_from_forms(data)
	data.prons.ppr = stem6 .. "jɑ̃"
end

conj["être"] = function(data)
	data.forms.ind_p_1s = "suis"
	data.forms.ind_p_2s = "es"
	data.forms.ind_p_3s = "est"
	data.forms.ind_p_1p = "sommes"
	data.forms.ind_p_2p = "êtes"
	data.forms.ind_p_3p = "sont"

	m_core.make_ind_i(data, "ét")
	m_core.make_ind_ps(data, "fu")
	m_core.make_ind_f(data, "ser")

	data.forms.sub_p_1s = "sois"
	data.forms.sub_p_2s = "sois"
	data.forms.sub_p_3s = "soit"
	data.forms.sub_p_1p = "soyons"
	data.forms.sub_p_2p = "soyez"
	data.forms.sub_p_3p = "soient"

	m_core.make_imp_p_sub(data)
	data.forms.pp = "été"
	data.forms.ppr = "étant"

	local root_s = rsub(dopron(data, "sa"),"sa$","")
	local root_e = rsub(dopron(data, "é"),"e$","")
	local root_f = rsub(dopron(data, "fa"),"fa$","")

	local stem = root_e .. "ɛ"
	local stem2 = root_e .. "e.t"
	local stem3 = root_f .. "fy"
	local stem4 = root_s .. "sə.ʁ"
	local stem5 = root_s .. "swa"
	local stem6 = root_s .. "swa."

	data.prons.ind_p_1s = root_s .. "sɥi"
	data.prons.ind_p_2s = stem
	data.prons.ind_p_3s = stem
	data.prons.ind_p_1p = root_s .. "sɔm"
	data.prons.ind_p_2p = stem .. "t"
	data.prons.ind_p_3p = root_s .. "sɔ̃"
	m_pron.ind_i(data, stem2)
	m_pron.ind_ps(data, stem3)
	m_pron.ind_f(data, stem4)
	m_pron.sub_p(data, stem5, stem6)

	data.prons.imp_p_2s = stem5
	data.prons.imp_p_1p = stem6 .. "jɔ̃"
	data.prons.imp_p_2p = stem6 .. "je"
	data.prons.ppr = stem2 .. "ɑ̃"
	data.prons.pp = stem2 .. "e"

	data.cat = "defective"
end

conj["estre"] = function(data)
	conj["être"](data)

	for key,val in pairs(data.forms) do
		data.forms[key] = rsub(val, "[éê]", "es")
		data.forms[key] = rsub(data.forms[key], "û", "us")
		data.forms[key] = rsub(data.forms[key], "ai", "oi")
	end

	data.forms.ind_ps_1p = "fumes"
	data.forms.sub_pa_3s = "fust"
	data.forms.pp = "esté"
end

conj["naitre"] = function(data)
	-- future stem must be nil here because we are called from conj["naître"]
	construct_non_er_conj(data, "nai", "naiss", "naiss", "naqui", nil, "né")
end

conj["naître"] = function(data)
	conj["naitre"](data)
	data.forms.ind_p_3s = "naît"
end

conj["envoyer"] = function(data)
	data.notes = "This verb is is one a few verbs that conjugate like " .. link("noyer") .. ", except in the future and conditional, where they conjugate like " .. link("voir") .. "."

	m_core.make_ind_p_e(data, "envoi", "envoy", "envoy")
	m_core.make_ind_f(data, "enverr")

	local stem = dopron(data, "envoi")
	local stem2 = stem .. ".j"
	local stem3 = dopron(data, "envè") .. ".ʁ"

	m_pron.er(data, stem, stem2)
	m_pron.ind_f(data, stem3)
	data.group = 1
	data.irregular = "yes"
end

conj["irreg-aller"] = function(data)
	data.notes = "The verb ''{stem}aller'' has a unique and highly irregular conjugation. The second-person singular imperative ''[[va]]'' additionally combines with ''[[y]]'' to form ''[[vas-y]]'' instead of the expected ''va-y''."

	m_core.make_ind_p_e(data, "all")
	m_core.make_ind_f(data, "ir")
	m_core.make_sub_p(data, "aill", "all")

	local stem = dopron(data, "a")
	local stem2 = dopron(data, "i") .. ".ʁ"

	m_pron.er(data, stem .. "l", stem .. ".l")
	m_pron.ind_f(data, stem2)
	m_pron.sub_p(data, stem .. "j", stem .. ".l")

	setform(data, "ind_p_1s", "vais")
	setform(data, "ind_p_2s", "vas")
	setform(data, "ind_p_3s", "va")
	setform(data, "ind_p_3p", "vont")
	setform(data, "imp_p_2s", "va")
end

conj["dire"] = function(data)
	construct_non_er_conj(data, "di", "dis", "dis", "di", nil, "dit")

	if data.stem == "" or data.stem == "re" then
		setform(data, "ind_p_2p", "dites")
		setform(data, "imp_p_2p", "dites")
	else
		data.notes = "This verb is one of a group of " .. link("-re") .. " verbs all ending in ''-dire''. "
		data.notes = data.notes .. "They are conjugated exactly like " .. link("dire") .. ", "
		data.notes = data.notes .. "but with a different second-person plural indicative present (that is, like " .. link("confire") .. "). "
		data.notes = data.notes .. "Members of this group include " .. link(data.stem == "contre" and "dédire" or "contredire") .. " and "
		data.notes = data.notes .. link(data.stem == "inter" and "dédire" or "interdire") .. "."
	end
end

conj["vivre"] = function(data)
	construct_non_er_conj(data, "vi", "viv", "viv", "vécu")
end

conj["mourir"] = function(data)
	construct_non_er_conj(data, "meur", "mour", "meur", "mouru", "mourr",
		"mort")
end

conj["savoir"] = function(data)
	construct_non_er_conj(data, "sai", "sav", "sav", "su", "saur", nil,
		"sach")
	m_core.make_imp_p_sub(data)
	setform(data, "ppr", "sachant")
	generate_imp_pron_from_forms(data)
end

conj["pouvoir"] = function(data)
	construct_non_er_conj(data, "peu", "pouv", "peuv", "pu", "pourr", nil,
		"puiss")
	data.forms.ind_p_1s = "peux"
	data.forms.ind_p_2s = "peux"
	m_core.clear_imp(data)
	data.cat = "欠如"
end

conj["ouloir"] = function(data) -- vouloir, revouloir, douloir
	construct_non_er_conj(data, "eu", "oul", "eul", "oulu", "oudr", nil,
		"euill", "oul")
	data.forms.ind_p_1s = "eux"
	data.forms.ind_p_2s = "eux"
	if data.stem == "v" then -- irregular imperative for vouloir
		setform(data, "imp_p_2s", {"eux", "euille"})
		setform(data, "imp_p_1p", {"oulons", "euillons"})
		setform(data, "imp_p_2p", {"oulez", "euillez"})
	else
		data.forms.imp_p_2s = "eux"
	end
end

conj["bruire"] = function(data)
	construct_non_er_conj(data, "bruis", "bruiss", "bruiss", "brui")
end

conj["ensuivre"] = function(data)
	data.notes = "これは不定詞、第三人称単数形及び複数形"
		.. "のみを持つ[[欠如動詞]]である。"
	construct_non_er_conj(data, "ensui", "ensuiv", "ensuiv", "ensuivi")
	only_third_verb(data)
	data.cat = "欠如"
end

conj["frire"] = function(data)
	data.notes = "This verb is defective and it is not conjugated in certain"
		.. " tenses and plural persons. Using " .. link("faire") ..
		" '''frire''' is recommended."
	construct_non_er_conj(data, "fri", "fris", "fris", "fri", nil, "frit")
	-- clear subjunctive present and past
	m_core.make_sub_pa(data, "—")
	m_core.make_sub_p(data, "—")
	-- clear plural forms
	for _, k in ipairs(all_verb_props) do
		if rmatch(k, "[123]p") then
			data.forms[k] = "—"
		end
	end
	data.cat = "欠如"
end

conj["plaire"] = function(data)
	data.notes = link("plaire") .. " and its derived verbs conjugate like "
		.. link("taire") .. ", except that the third person singular of the "
		.. "present indicative may take a circumflex on the ‘i’."
	construct_non_er_conj(data, "plai", "plais", "plais", "plu")
	data.forms.ind_p_3s = {"plaît", "plait"}
end

conj["suivre"] = function(data)
	construct_non_er_conj(data, "sui", "suiv", "suiv", "suivi")
end

conj["taire"] = function(data)
	construct_non_er_conj(data, "tai", "tais", "tais", "tu")
end

conj["valoir"] = function(data)
	construct_non_er_conj(data, "vau", "val", "val", "valu", "vaudr", nil,
		data.stem == "pré" and "val" or "vaill", "val")
	data.forms.ind_p_1s = "vaux"
	data.forms.ind_p_2s = "vaux"
	m_core.clear_imp(data)
	data.cat = "欠如"
end

conj["vêtir"] = function(data)
	data.notes = "これは第三群動詞の不規則動詞である。"
		.. "Unlike regular -ir verbs, this conjugation does not include "
		.. "the infix " .. link("-iss-") .. "."
	construct_non_er_conj(data, "vêt", "vêt", "vêt", "vêti", nil, "vêtu")
end

local function call_conj(data, conjtyp, pronstem)
	data.pronstem = pronstem or strip_respelling_ending(data.pron, data.forms.inf) or data.stem
	conj[conjtyp](data)
end

-- Conjugate the verb according to the TYPE, which is either explicitly
-- specified by the caller of {{fr-conj-auto}} or derived automatically.
-- NOTE: Verbs of of type 'xxer' (i.e. 'appeler', 'jeter' and derivatives)
-- need to have their type explicitly specified, e.g.:
-- * 'ler' for 'appeler' and derivatives
-- * 'ter' for 'jeter' and derivatives
--
-- appeler: {{fr-conj-auto|appe|ler}}
-- jeter: {{fr-conj-auto|je|ter}}
local function conjugate(data, typ)
	data.forms.inf = typ
	local future_stem = rsub(data.forms.inf, "e$", "")
	m_core.make_ind_f(data, future_stem)

	local cons = rmatch(typ, "^(" .. written_cons_c .. ")er$")
	if cons and typ ~= "cer" and typ ~= "ger"  and typ ~= "yer" then
		data.stem = data.stem .. cons
		call_conj(data, "xxer", strip_respelling_ending(data.pron, "er"))
		return
	end
	local cons = rmatch(typ, "^e(" .. written_cons_c .. "+)er$")
	if cons and typ ~= "ecer" and typ ~= "eger" and typ ~= "eyer" then
		data.stem = data.stem .. "e" .. cons
		call_conj(data, "e-er", strip_respelling_ending(data.pron, "er"))
		return
	end
	local cons = rmatch(typ, "^é(" .. written_cons_c .. "+)er$")
	if cons and typ ~= "écer" and typ ~= "éger"  and typ ~= "éyer" then
		data.stem = data.stem .. "é" .. cons
		call_conj(data, "é-er", strip_respelling_ending(data.pron, "er"))
		return
	end
	local cons = rmatch(typ, "^é([gq]u)er$") -- alléguer, disséquer, etc.
	if cons then
		data.stem = data.stem .. "é" .. cons
		call_conj(data, "é-er", strip_respelling_ending(data.pron, "er"))
		return
	end
	if alias[typ] then
		data.stem = data.stem .. rsub(typ, alias[typ] .. "$", "")
		data.forms.inf = alias[typ]
		call_conj(data, alias[typ])
	elseif conj[typ] then
		call_conj(data, typ)
	elseif typ ~= "" then
		error('The type "' .. typ .. '" is not recognized')
	end
end

-- Autodetect the conjugation type and extract the preceding stem. We have
-- special handling for verbs in -éCer and -eCer for C = consonant. Otherwise,
-- the conjugation type is the longest suffix of the infinitive for which
-- there's an entry in conj[], and stem is the preceding text. (As an
-- exception, certain longer suffixes are mapped to the conjugation type of
-- shorter suffixes using alias[]. An example is 'connaitre', which conjugates
-- like '-aitre' verbs rather than like 'naitre' and its derivatives.) Note
-- that for many irregular verbs, the "stem" is actually the prefix, or empty
-- if the verb has no prefix.
local function auto(pagename)
	local stem
	-- check for espérer, céder, etc.; exclude -écer, -éger, -éyer
	stem = rmatch(pagename, "^(.*é" .. written_cons_c .. "*" .. written_cons_no_cgy_c .. ")er$")
	if stem then
		return stem, "é-er"
	end
	-- check for alléguer, disséquer, etc.
	stem = rmatch(pagename, "^(.*é[gq]u)er$")
	if stem then
		return stem, "é-er"
	end
	-- check for acheter, etc.; exclude -exer, -ecer, -eger, -eyer
	stem = rmatch(pagename, "^(.*e" .. written_cons_no_cgyx_c .. ")er$")
	if stem then
		return stem, "e-er"
	end
	-- check for sevrer, etc.; exclude -ller, -rrer, -rler (perler)
	stem = rmatch(pagename, "^(.*e" .. written_cons_no_lryx_c .. "[lr])er$")
	if stem then
		return stem, "e-er"
	end
	stem = ""
	local typ = pagename
	while typ ~= "" do
		if conj[typ] then break end
		if alias[typ] then
			stem = stem .. rsub(typ,alias[typ].."$","")
			typ = alias[typ]
			break
		end
		stem = stem .. rsub(typ,"^(.).*$","%1")
		typ = rsub(typ,"^.","")
	end
	if typ == "" then
		return "",""
	end
	return stem,typ
end

-- Append elements of TAB2 to the elements of TAB1, converting them to lists
-- as necessary.
local function append_tables(tab1, tab2)
	for k, values in pairs(tab2) do
		local t1 = tab1[k]
		if type(t1) ~= "table" then
			t1 = {t1}
		end
		if type(values) ~= "table" then
			values = {values}
		end
		for _, val in ipairs(values) do
			ut.insert_if_not(t1, val)
		end
		tab1[k] = t1
	end
end

-- This is meant to be invoked by the module itself, or possibly by a
-- different version of the module (for comparing changes to see whether
-- they have an effect on conjugations or pronunciations).
function export.do_generate_forms(args)
	local data
	local stem = args[1] or ""
	local typ = args[2] or ""
	local argspron = args.pron
	local refl = false
	if typ == "" then typ = stem; stem = ""; end

	local PAGENAME = mw.title.getCurrentTitle().text

	if stem == "" and typ == "" then
		-- most common situation, {{fr-conj-auto}}
		stem, typ = auto(PAGENAME)
	elseif stem == "" then
		-- explicitly specified stem, e.g. {{fr-conj-auto|aimer}} in userspace
		-- (NOTE: stem moved to typ above)
		stem, typ = auto(typ)
	-- else, explicitly specified stem and type, e.g. {{fr-conj-auto|appe|ler}}
	end

	-- autodetect reflexives
	if rfind(stem, "^s'") then
		stem = rsub(stem, "^s'", "")
		argspron = strip_respelling_beginning(argspron, "s'", "split")
		refl = true
	elseif rfind(stem, "^se ") then
		stem = rsub(stem, "^se ", "")
		argspron = strip_respelling_beginning(argspron, "se ", "split")
		refl = true
	end

	local pronargs = argspron and rsplit(argspron, ",") or {false}
	local all_forms, all_prons 
	for i = 1, #pronargs do
		local pronarg = pronargs[i]
		if pronarg == false then pronarg = nil end
		data = {
			refl = refl,
			stem = stem,
			aux = "avoir",
			pron = pronarg,
			forms = {},
			prons = {},
			cat = {},
			group = 3
		}
		conjugate(data, typ)
		if type(data.cat) ~= "table" then
			data.cat = {data.cat}
		end
		if i == 1 then
			all_forms = data.forms
			all_prons = data.prons
		else
			append_tables(all_forms, data.forms)
			append_tables(all_prons, data.prons)
		end
	end
	data.forms = all_forms
	data.prons = all_prons

	-- FIXME! From here on out we use the value of data.notes, data.stem
	-- and data.cat as set/modified in the conjugation functions of the last
	-- iteration of the loop above. As it happens, this doesn't matter
	-- because we iterate over pronunciations keeping the stem and conjugation
	-- type the same, but might matter one day if we break this assumption.
	m_core.extract(data, args)

	if args.archaic then
		for k, v in pairs(data.forms) do
			data.forms[k] = map(v, function(val)
				val = rsub(val, "ai", "oi")
				val = rsub(val, "â", "as")
				return val end)
		end
	end

	if args.impers or args.onlythird then
		if data.notes then
			data.notes = data.notes .. "\n"
		else
			data.notes = ""
		end
		table.insert(data.cat, "欠如")
	end
	if args.impers then
		data.notes = data.notes .. "これは非人称動詞で第三人称単数形でのみ活用する。"
		impersonal_verb(data)
		table.insert(data.cat, "非人称")
	elseif args.onlythird then
		data.notes = data.notes .. "この動詞は第三人称でのみ活用する。"
		only_third_verb(data)
	end

	if args.note then
		if data.notes then
			data.notes = data.notes .. "\n"
		else
			data.notes = ""
		end
		data.notes = data.notes .. args.note
	end
	
	if data.notes then data.notes = rsub(data.notes, "{stem}", data.stem) end
	for key,val in pairs(data.forms) do
		if type(val) == "table" then
			for i,form in ipairs(val) do
				if form ~= "—" then
					data.forms[key][i] = data.stem .. form
				end
			end
		else
			if val ~= "—" then
				data.forms[key] = data.stem .. val
			end
		end
	end

	-- args.refl can override data.refl
	if args.refl == "n" or args.refl == "no" then
		data.refl = false
	elseif args.refl then
		data.refl = true
	end
	if data.refl then m_core.refl(data) end

	if etre[data.forms.inf] then
		data.aux = "être"
	elseif avoir_or_etre[data.forms.inf] then
		data.aux = "avoir or être"
	end
	if args.aux == "a" or args.aux == "avoir" then
		data.aux = "avoir"
	elseif args.aux == "e" or args.aux == "être" then
		data.aux = "être"
	elseif args.aux == "ae" or args.aux == "avoir,être" or args.aux == "avoir or être" then
		data.aux = "avoir or être"
	elseif args.aux then
		error("Unrecognized value for aux=, should be 'a', 'e', 'ae', 'avoir', 'être', or 'avoir,être'")
	end

	data.forms.inf_nolink = data.forms.inf_nolink or data.forms.inf
	data.forms.ppr_nolink = data.forms.ppr_nolink or data.forms.ppr
	data.forms.pp_nolink = data.forms.pp_nolink or data.forms.pp

	if not data.irregular then
		if data.group == 1 or data.group == 2 then
			data.irregular = "no"
		else
			data.irregular = "yes"
		end
	end

	return data
end

function export.generate_forms(frame)
	local args = clone_args(frame)
	local data = export.do_generate_forms(args)
	local retval = {}
	for arraytype = 1, 2 do
		local arrayname = arraytype == 1 and "forms" or "prons"
		local array = data[arrayname]
		for _, prop in ipairs(all_verb_props) do
			local val = array[prop]
			if type(val) ~= "table" then val = {val} end
			local newval = {}
			for _, form in ipairs(val) do
				if not rmatch(form, "—") then
					table.insert(newval, form)
				end
			end
			-- Ignore pronunciation if dash present in form.
			-- FIXME, we shouldn't generate the pronunciation at all in that
			-- case, so we can support both dash and another form.
			if arrayname == "prons" then
				local val = data.forms[prop]
				if type(val) == "string" then val = {val} end
				local found_dash = false
				for _, form in ipairs(val) do
					if rmatch(form, "—") then
						found_dash = true
						break
					end
				end
				if found_dash then
					newval = {}
				end
			end
			if #newval > 0 then
				table.insert(retval, arrayname .. "." .. prop .. "=" .. table.concat(newval, ","))
			end
		end
	end
	return table.concat(retval, "|")
end

-- The main entry point.
-- This is the only function that can be invoked from a template.
function export.show(frame)
	local args = clone_args(frame)
	local args_clone
	if test_new_fr_verb_module then
		-- clone in case export.do_generate_forms() modifies args
		-- (I don't think it does currently)
		args_clone = mw.clone(args)
	end

	local data = export.do_generate_forms(args)

	-- Test code to compare existing module to new one.
	if test_new_fr_verb_module then
		local m_new_fr_verb = require("モジュール:User:Benwing2/fr-verb")
		local newdata = m_new_fr_verb.do_generate_forms(args_clone)
		local difconj = false
		local difforms = {}
		for arraytype = 1, 2 do
			local arrayname = arraytype == 1 and "forms" or "prons"
			local array = data[arrayname]
			local newarray = newdata[arrayname]
			for _, prop in ipairs(all_verb_props) do
				local val = array[prop]
				local newval = newarray[prop]
				-- deal with possible impedance mismatch between plain string
				-- and list
				if type(val) == "string" then val = {val} end
				if type(newval) == "string" then newval = {newval} end
				if not ut.equals(val, newval) then
					if test_new_fr_verb_module == "error" then
						table.insert(difforms, arrayname .. "." .. prop .. " " .. (val and table.concat(val, ",") or "nil") .. " || " .. (newval and table.concat(newval, ",") or "nil"))
					end
					difconj = true
				end
			end
		end
		if #difforms > 0 then
			error(table.concat(difforms, "; "))
		end
		track(difconj and "different-conj" or "same-conj")
	end

	m_core.link(data)

	local categories = {}
	if data.aux == "être" then
		table.insert(categories, "フランス語 助動詞にêtreを用いる動詞")
	elseif data.aux == "avoir or être" then
		table.insert(categories, "フランス語 助動詞にavoirかêtreを用いる動詞")
	end
	if data.conjcat then
		table.insert(categories, "フランス語 " .. data.conjcat .. "で終わる動詞")
	end
	for _, cat in ipairs(data.cat) do
		table.insert(categories, "フランス語 " .. cat .. "動詞")
	end
	for _, group in ipairs(type(data.group) == "table" and data.group or {data.group}) do
		if group == 1 then
			table.insert(categories, "フランス語 第一群動詞")
		elseif group == 2 then
			table.insert(categories, "フランス語 第二群動詞")
		else
			table.insert(categories, "フランス語 第三群動詞")
		end
	end
	if data.irregular == "yes" then
			table.insert(categories, "フランス語 不規則動詞")
	end

	return m_conj.make_table(data) .. m_utilities.format_categories(categories, lang)
end

return export

-- For Vim, so we get 4-space tabs
-- vim: set ts=4 sw=4 noet: