text:
Module:fr-verb

--[=[

Author: originally Kc kennylau; rewritten by Benwing

This implements. 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. (DONE) '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. (REMOVED THE ARGUMENTS, NOT USED) Document the various override arguments. 6. Implement conjugation for -éyer. 7. (MAYBE? MAYBE NOT NECESSARY, 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 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. 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. 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 support 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 -- Tracking/fr-verb/different-conj (see what links there to see -- the differing verbs; there's also 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("Module:fr-verb/core") local m_pron = require("Module:fr-verb/pron") local m_links = require("Module:links") local m_conj = require("Module:fr-conj") local m_fr_pron = require("Module:fr-pron") local lang = require("Module:languages").getByCode("fr") local m_table = require("Module:table") local m_utilities = require("Module:utilities") local m_debug = require("Module:debug")

local rfind = mw.ustring.find local rsubn = mw.ustring.gsub local rmatch = mw.ustring.match local rsplit = mw.text.split local usub = mw.ustring.sub

local written_vowel = "aàâeéèêiîoôuûäëïöüÿ" local written_cons_c = "[^%-" .. written_vowel .. "]" local written_cons_no_y_c = "[^%-y" .. 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

-- Map a function over one of the following: -- (1) a single string (return value will be FUN(STRING)) -- (2) a list SEQ of either strings or tables of the form {"STEM", respelling="RESPELLING"}; the return value is a --    list of calls to FUN, with one element per element in SEQ, flattened if DO_FLATMAP is specified and the return --    value of FUN is a list; if an element of SEQ is a string, the corresponding return value will be FUN(STRING); --    if an element of SEQ is a table of the above form, the corresponding return value will be FUN("STEM"), unless --    third arg USE_RESPELLING is given, in which case the corresponding return value will be FUN("RESPELLING"). local function map(seq, fun, use_respelling, do_flatmap) if type(seq) == "table" then local ret = {} for _, s in ipairs(seq) do			if type(s) == "table" then if use_respelling then assert(s.respelling) s = s.respelling else s = s[1] end end local retval = fun(s) if do_flatmap and type(retval) == "table" then for _, item in ipairs(retval) do					m_table.insertIfNot(ret, item) end else m_table.insertIfNot(ret, retval) end 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("Module: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, "respelling", "flatmap") end

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

local function copyform(data, fromform, toform, newformval) -- Need to clone objects when copying forms, otherwise we get duplicated prefixes added in case of -- prefixed verbs. data.forms[toform] = newformval or mw.clone(data.forms[fromform]) data.prons[toform] = mw.clone(data.prons[fromform]) 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" }

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

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

local function make_passe_simple(data, past_stem, er_past) -- Passé simple if er_past then m_core.make_ind_ps_a(data, past_stem) else m_core.make_ind_ps(data, past_stem) end if past_stem ~= "—" then local past_stem_pron = dopron(data, past_stem) if er_past then m_pron.ind_ps_a(data, past_stem_pron) else m_pron.ind_ps(data, past_stem_pron) end end end

local function make_future_conditional(data, fut_stem) -- Future/conditional if not fut_stem then fut_stem = rsub(data.forms.inf, "e$", "") end m_core.make_ind_f(data, fut_stem) 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 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 indicative 1s/2s/3s and the imperative 2s; -- * PRES_12P_STEM is used for pres indicative/imperative 1p/2p, the whole of the imperfect, the present participle, --   and (unless PRES_SUBJ_STEM is given) the pres subjunctive 1p/2p; -- * PRES_3P_STEM is used for pres indicative 3p and pres subjunctive 1s/2s/3s/3p; -- * PAST_STEM is used for the past historic, the imperfect subjunctive and (unless PP is given) the 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 any 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. -- * ER_PAST, if true, specifies that the past historic and imperfect subjunctive follow an -er type of conjugation. -- -- Any of the stem arguments may be "—" to indicate that it is missing, or a table, where each element can be a string -- (a stem) or a table of the form {"STEM", RESPELLING="RESPELLING"}, specifying a stem to use for constructing the -- verb forms and the corresponding respelling to use when constructing the pronunciation. This is used, for example, -- in mourir, courir and avoir. 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, er_past) 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

-- 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, "respelling", "flatmap") 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

make_passe_simple(data, past_stem, er_past) make_future_conditional(data, fut_stem)

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 it 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 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 = "This verb is part of a group of " .. link("-er") .. " verbs for which 'c' is softened to a 'ç' before the vowels 'a' and 'o'." 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 = "This is a regular " .. link("-er") .. " verb, but the stem is written {stem}ge- before endings that begin with -a- or -o- " data.notes = data.notes .. "(to indicate that the -g- is a \"soft\" " .. IPA("/ʒ/") .. " and not a \"hard\" " .. IPA("/ɡ/") .. "). " data.notes = data.notes .. "This spelling-change occurs in all verbs in -ger, such as " data.notes = data.notes .. link(data.stem == "nei" and "bouger" or "neiger") .. " and " data.notes = data.notes .. link(data.stem == "man" and "ranger" or "manger") .. "."

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 "		.. "either group, according to the writer's preference)."

m_core.make_ind_p_e(data, {"ay", "ai"}, "ay", "ay") construct_er_pron(data, "ay", {"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", "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("Stem '" .. data.stem .. "' should end with -e- + consonant") 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 now also 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("Stem '" .. data.stem .. "' should end with -e- + one or more consonants") end local stem = 'e' .. consonant local stem2 = 'è' .. consonant data.forms.inf = stem .. "er" -- not e-er data.stem = newstem data.pronstem = strip_respelling_ending(data.pron, data.forms.inf) or data.stem

data.notes = "This verb is conjugated like " .. link("parler") .. ", "	data.notes = data.notes .. "except 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 .. "as in the third-person singular present indicative ''il {stem}" .. stem2 .. "e and the third-person singular future indicative il {stem}" .. stem2 .. "era''. "

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 -cer  " 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 -é-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, "è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(data.stem .."s", "(je, tu) " .. data.stem .. "s") .. " and " .. link(data.stem .. "t", "(il) " .. data.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 = "This is a regular verb of the second conjugation, like " .. (data.stem == "fin" and link("nourrir") or link("finir")) .. ", "		.. (data.stem == "chois" and link("nourrir") or link("choisir")) .. ", and most other verbs with infinitives ending in " .. link("-ir") .. ". One salient feature of this conjugation is the repeated " .. "appearance of the infix " .. 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", respelling="oill"}},		{"ouïss", "oi"}, "ouï", {"ouïr", "oir", "orr"}) 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) -- Pronunciation in future/cond as if written sursoir- not surseoir- construct_non_er_conj(data, "sursoi", "sursoy", "sursoi", "sursi", ,		"sursis") data.conjcat = "seoir" end

conj["seoir"] = function(data) data.notes = "This is a defective verb, only conjugated in the third person."

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 = "defective" 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",, "enu")

if usub(data.stem,-1) == "t" then data.notes = "This is a verb in a group of " .. link("-ir") .. " verbs. All verbs ending in " .. "-tenir, such as " .. link(data.stem == "cont" and "retenir" or "contenir") .. " and " .. link(data.stem == "dét" and "retenir" or "détenir") .. ", are conjugated this way. Such verbs are the only verbs" .. " whose the past historic and subjunctive imperfect endings" .. " do not start in one of these thematic vowels (-a-, -i-, -u-)." data.conjcat = "tenir" else data.notes = "This is a verb in a group of " .. link("-ir") .. " verbs. All verbs ending in " .. "-venir, such as " .. link(data.stem == "conv" and "revenir" or "convenir") .. " and " .. link(data.stem == "dev" and "revenir" or "devenir") .. ", are conjugated this way. Such verbs are the only verbs" .. " whose the past historic and subjunctive imperfect endings" .. " do not start in one of these thematic vowels (-a-, -i-, -u-)." 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 = "This verb is conjugated like " .. link(data.stem == "ouv" and "couvrir" or "ouvrir") .. " and " .. link(data.stem == "off" and "souffrir" or "offrir") .. ". "		.. "It is conjugated like a regular " .. link("-er") .. " verb in the present and imperfect indicative, present subjunctive, " .. "imperative, and present participle; it is conjugated like a regular " .. link("-ir") .. " verb in the infinitive, " .. "future indicative, conditional, past historic, and imperfect subjunctive; " .. "and its past participle " .. link(data.stem .. "ert") .. " is irregular."

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 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 = "This is a defective verb, only conjugated in certain tenses." -- 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 = "This verb is defective in that it is not conjugated in certain tenses. It has no indicative imperfect form, no imperative form and no present participle." 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 = "This verb is defective and is only conjugated in the third-person." 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 = "defective" end

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

conj["courir"] = function(data) data.notes = "This verb is conjugated like other regular " .. link("-ir") .. " verbs, " data.notes = data.notes .. "except that in the conditional and future tenses an extra 'r' is added to the end of the stem " data.notes = data.notes .. "and the past participle ends in -u. All verb ending in -courir are conjugated this way."

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

conj["falloir"] = function(data) data.notes = "This verb is defective, only conjugated in the third-person singular." construct_non_er_conj(data, "fau", "fall", "fall", "fallu", "faudr", nil, "faill") impersonal_verb(data) data.cat = {"defective", "impersonal"} 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 = "defective" 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 = "This is a defective verb, and is only conjugated in the present and imperfect indicative." construct_non_er_conj(data, "gi", "gis", "gis", "—", "—", "—", "—") data.forms.ind_p_3s = "gît" m_core.clear_imp(data) data.cat = "defective" 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-") .. ": {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."

construct_non_er_conj(data,, ,		, "u", ) end

conj["indre"] = function(data) data.notes = "This verb is conjugated like " .. link(data.stem == "pei" and "plaindre" or "peindre") .. ". It uses the same endings as " .. link("rendre") .. " or " .. link("vendre") .. ", but its -nd- becomes -gn- before a " .. "vowel, and its past participle ends in 't' instead of a vowel." 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." construct_non_er_conj(data, "rai", "ray", "rai", "ray", nil, "rait", nil, nil, nil, "er past") end

conj["clore"] = function(data) data.notes = "This verb is not conjugated in certain tenses."

construct_non_er_conj(data, "clo", "clos", "clos", "—", nil, "clos") m_core.make_ind_i(data, "—") -- no imperfect data.forms.ind_p_3s = "clôt" data.cat = "defective" 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(data.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 == "" or data.stem == "re" 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(data.stem == "re" and "recroire" or "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", "cru") 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(data.stem .. "bat") .. " and " .. link(data.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 = "This verb is conjugated like " .. link("mettre") .. ". That means it " else data.notes = "This verb " end data.notes = data.notes .. "is conjugated like " .. link("battre") .. " except that its past participle is " .. link(data.stem .. "mis") .. ", "	data.notes = data.notes .. "not *{stem}mettu, and its past historic and imperfect subjunctive " data.notes = data.notes .. "are formed with {stem}mi-, not *{stem}metti-."

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 = "This verb is not conjugated in certain tenses." construct_non_er_conj(data, "pai", "paiss", "paiss", "pu") --data.cat = "defective" -- FIXME: Not true with pu as past participle? end

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

conj["pleuvoir"] = function(data) data.notes = "This is a defective verb, only conjugated in the " if data.stem == "re" then data.notes = data.notes .. "third-person singular." else data.notes = data.notes .. "third-person. The third-person plural forms are only used figuratively." end

construct_non_er_conj(data, "pleu", "pleuv", "pleuv", "plu", "pleuvr") if data.stem == "re" then impersonal_verb(data) data.cat = {"defective", "impersonal"} else only_third_verb(data) data.cat = "defective" end end

conj["pourvoir"] = function(data) data.notes = "Pourvoir and its derived verbs conjugate like " .. link("voir") .. ", except that their past historic indicative and imperfect subjunctive are in -vu- instead of -vi-."

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",, , "fi", "fer", "fait",		"fass") setform(data, "ind_p_2p", "faites") setform(data, "ind_p_3p", "font") copyform(data, "ind_p_2p", "imp_p_2p") 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) -- Need to specify a value for singular present to get proper pronunciation for present tense, -- even though we override it. construct_non_er_conj(data, "a", "av", "—",, {"aur", {"aur", respelling="ôr"}}, nil,		"ai", "ay") setform(data, "ind_p_1s", "ai") setform(data, "ind_p_2s", "as", "a") setform(data, "ind_p_3s", "a") setform(data, "ind_p_3p", "ont") setform(data, "ppr", "ayant") data.forms.sub_p_3s = "ait" setform(data, "sub_p_1p", "ayons") setform(data, "sub_p_2p", "ayez") copyform(data, "sub_p_1s", "imp_p_2s") copyform(data, "sub_p_1p", "imp_p_1p") copyform(data, "sub_p_2p", "imp_p_2p") end

conj["être"] = function(data) construct_non_er_conj(data, "e", "ét", "—", "fu", "ser", "été", "soi", "soy") setform(data, "ind_p_1s", "suis") setform(data, "ind_p_2s", "es") setform(data, "ind_p_3s", "est") setform(data, "ind_p_1p", "sommes") setform(data, "ind_p_2p", "êtes") setform(data, "ind_p_3p", "sont")

setform(data, "sub_p_1s", "sois") copyform(data, "sub_p_1s", "sub_p_2s") copyform(data, "sub_p_1s", "sub_p_3s", "soit") setform(data, "sub_p_1p", "soyons") setform(data, "sub_p_2p", "soyez")

copyform(data, "sub_p_2s", "imp_p_2s") copyform(data, "sub_p_1p", "imp_p_1p") copyform(data, "sub_p_2p", "imp_p_2p") end

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

for key,val in pairs(data.forms) do		data.forms[key] = map(val, function(form)			form = rsub(form, "[éê]", "es")			form = rsub(form, "û", "us")			form = rsub(form, "ai", "oi")			return form		end) 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 one of 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") construct_er_pron(data, "envoy", "envoi") make_future_conditional(data, "enverr") 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."

-- Need to specify a value for singular present to get proper pronunciation for present tense, -- even though we override it. construct_non_er_conj(data, "va", "all", "—", "all", "ir", "allé", "aill", "all", nil, "er past") setform(data, "ind_p_1s", "vais") -- TLFi says /va/ even for 2s, not /vɑ/. setform(data, "ind_p_2s", "vas", "va") setform(data, "ind_p_3s", "va") setform(data, "ind_p_3p", "vont") copyform(data, "ind_p_3s", "imp_p_2s") 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") copyform(data, "ind_p_2p", "imp_p_2p") 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",, "mort") end

conj["savoir"] = function(data) construct_non_er_conj(data, "sai", "sav", "sav", "su", {"saur", {"saur", respelling="sôr"}}, nil, "sach") copyform(data, "sub_p_1s", "imp_p_2s") -- sache setform(data, "imp_p_1p", "sachons") setform(data, "imp_p_2p", "sachez") setform(data, "ppr", "sachant") 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 = "defective" 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 = "This verb is defective, and is only used in the " .. "infinitive and the third-person singular and plural forms." construct_non_er_conj(data, "ensui", "ensuiv", "ensuiv", "ensuivi") only_third_verb(data) data.cat = "defective" 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 = "defective" 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 = "defective" end

conj["vêtir"] = function(data) data.notes = "This is an irregular verb of the third conjugation. " .. "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 or derived automatically. 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)

if typ == "xxer" or typ == "e-er" or typ == "é-er" then call_conj(data, typ, 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, argstype, argsstem) local stem

if argstype then local tostrip if argstype == "xxer" or argstype == "é-er" or argstype == "e-er" then tostrip = "er" else tostrip = argstype end stem = argsstem or strip_respelling_ending(pagename, tostrip) return stem, argstype end

-- check for espérer, céder, etc.; exclude y so as not to be confused by acétyler, déméthyler; -- exclude -écer, -éger, -éyer stem = rmatch(pagename, "^(.*é" .. written_cons_no_y_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			m_table.insertIfNot(t1, val) end tab1[k] = t1	end end

local verb_prefix_to_type = { {"les y en ", "lesyen"}, {"les en ", "lesen"}, {"s[’']en ", "reflen"}, {"se le ", "reflle"}, {"se la ", "reflla"}, {"se l[’']", "refll"}, {"se les y ", "refllesy"}, {"les y ", "lesy"}, {"se les ", "reflles"}, {"les ", "les"}, {"se l[’']y ", "reflly"}, {"l[’']y ", "l_y"}, {"l[’']en ", "l_en"}, {"l[’']", "l"}, {"le ", "le"}, {"la ", "la"}, {"s[’']y en ", "reflyen"}, {"y en ", "yen"}, {"en ", "en"}, {"s[’']y ", "refly"}, {"y ", "y"}, {"s[’']", "refl"}, {"se ", "refl"}, }

-- 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 prefix, preftype local pagename_from_args local PAGENAME = mw.title.getCurrentTitle.text

if stem == "" and typ == "" then pagename_from_args = args.pagename or PAGENAME else error("Specifying 1= or 2= not supported any more; use type=, stem= and/or pagename=") end

local argstype = args.type if argstype == "" then argstype = nil; end local argsstem = args.stem if argsstem == "" then argsstem = nil; end

stem, typ = auto(pagename_from_args, argstype, argsstem)

-- expand + and [...] notations if argspron then local pronvals = rsplit(argspron, ",") local expanded_pronvals = {} for _, pronval in ipairs(pronvals) do			table.insert(expanded_pronvals, m_fr_pron.canonicalize_pron(pronval, pagename_from_args)) end argspron = table.concat(expanded_pronvals, ",") end

-- autodetect prefixed verbs for _, pref_and_type in ipairs(verb_prefix_to_type) do		local pref, prefty = pref_and_type[1], pref_and_type[2] if rfind(stem, "^" .. pref) then stem = rsub(stem, "^" .. pref, "") argspron = strip_respelling_beginning(argspron, pref, "split") prefix = pref preftype = prefty break end 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 = { prefix = prefix, preftype = preftype, 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.

-- FIXME, allow all overrides if args.inf then data.forms.inf = args.inf end

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, "defective") end if args.impers then data.notes = data.notes .. "This verb is impersonal and is conjugated only in the third-person singular." impersonal_verb(data) table.insert(data.cat, "impersonal") elseif args.onlythird then data.notes = data.notes .. "This verb is conjugated only in the third person." 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 if type(form) == "table" then error(("Internal error: Saw table value for key '%s': %s"):format(key, mw.dumpObject(form))) end data.forms[key][i] = data.stem .. form end end else if val ~= "—" then data.forms[key] = data.stem .. val end end end

for _, pref_and_type in ipairs(verb_prefix_to_type) do		local prefty = pref_and_type[2] if args[prefty] == "n" or args[prefty] == "no" then if data.preftype == prefty then data.preftype = nil end elseif args[prefty] then data.preftype = prefty end end

if data.preftype then for key, val in pairs(data.forms) do			m_core.pref_sufs[data.preftype](data, key, val) end end

local aux_prefix = data.prefix or "" aux_prefix = rsub(aux_prefix, "l[ae] $", "l'") if args.aux == "a" or args.aux == "avoir" then data.aux = aux_prefix .. "avoir" elseif args.aux == "e" or args.aux == "être" then data.aux = aux_prefix .. "être" elseif args.aux == "ae" or args.aux == "avoir,être" or args.aux == "avoir or être" then data.aux = aux_prefix .. "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("Module: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 m_table.deepEquals(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, "French verbs taking être as auxiliary") elseif data.aux == "avoir]] or [[être" then table.insert(categories, "French verbs taking avoir or être as auxiliary") end if data.conjcat then table.insert(categories, "French verbs with conjugation " .. data.conjcat) end for _, cat in ipairs(data.cat) do table.insert(categories, "French " .. cat .. " verbs") end for _, group in ipairs(type(data.group) == "table" and data.group or {data.group}) do		if group == 1 then table.insert(categories, "French first group verbs") elseif group == 2 then table.insert(categories, "French second group verbs") else table.insert(categories, "French third group verbs") end end if data.irregular == "yes" then table.insert(categories, "French irregular verbs") end

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

return export

title: Module:fr-verb


text: kobato

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

title: kobato


text:
こばと

Noun

 * 1)  small dove

title: こばと


text: పదార్థం

title: పదార్థం


text: పదార్థములు

title: పదార్థములు


text:
αυτά μου φαίνονται κινέζικα

Phrase

 * 1)  it's all Greek to me

title: αυτά μου φαίνονται κινέζικα


text: శిరోభూషణములు

title: శిరోభూషణములు


text: నత్తులు

title: నత్తులు


text: కంకణములు

title: కంకణములు


text: కంటెలు

title: కంటెలు


text: కంఠాభరణములు

title: కంఠాభరణములు


text: కర్ణికలు

title: కర్ణికలు


text: దండకడియములు

title: దండకడియములు


text: శిరోమణులు

title: శిరోమణులు


text: మట్టెలు

title: మట్టెలు


text: వడ్డాణములు

title: వడ్డాణములు


text: ముక్కుపుడకలు

title: ముక్కుపుడకలు


text: భుజకీర్తులు

title: భుజకీర్తులు


text:
zutragen

Verb

 * 1) to carry (something to someone)
 * 2) to report, inform (someone of something)
 * 3) to take place; to transpire

title: zutragen


text:
पदार्थ

Etymology
.

Noun

 * 1) substance
 * 2)  matter

Etymology
.

Noun

 * 1) thing, substance, material object
 * 2)  dish, delicacy
 * 3)  matter

Noun

 * 1) the meaning of a word
 * 2) that which corresponds to the meaning of a word, a thing, material object, man, person

title: पदार्थ


text:
Rechtlosigkeit

Noun

 * 1) lawlessness (of place)
 * 2) lack of rights (of people)

title: Rechtlosigkeit


text: గుంపులు

title: గుంపులు


text:
dahinleben

Verb

 * 1) to exist
 * 2)  to vegetate

title: dahinleben


text:
αλαμπουρνέζικος

Etymology
Other proposed etymologies
 * From or  +  with change of [l] to [n]
 * From
 * Unlikely is the relation to

Adjective

 * 1)  unintelligible, gibberish
 * 2) queer, outlandish, odd
 * 1) queer, outlandish, odd

title: αλαμπουρνέζικος


text: Category:Pashto terms derived from Old French


text: Category:Pashto terms derived from Frankish


text: στολίστηκα

title: στολίστηκα


text: στόλισα

title: στόλισα


text:
στοιβάζομαι

Verb

 * 1) to cram, pack

title: στοιβάζομαι


text: στοιβάχτηκα

title: στοιβάχτηκα


text: στραβώνομαι

title: στραβώνομαι


text: στραβώθηκα

title: στραβώθηκα


text:
Citations:Congo

Noun: "Congregationalist"

 * 1904, , volume 94, p. 114:
 * The Congregationalists and plain Baptists held their services in the same house of worship, each taking its turn, yearly I think, in providing a clergyman. Elder Lincoln was the choice of the Congos at that time, a dear, simple-hearted old man...
 * 1922, Wisconsin Congregational Association, Wisconsin Congregational Church Life, volumes 41–45, p. 13:
 * The first speaker talked out of an experience in the church of fifty-two years. Rev. W. H. Zielger closed, with “Until the 70th.” Evidently, as the paper said, the “Congos had a large time.”
 * 1981,, “”. Reprinted 2008 in Wesley McNair (ed.), Today’s Best Maine Fiction, Down East Books, ISBN 9781461741725, p. 267:
 * Bill was out there, beckoning. Beyond him, beyond the Reach, she could see the Congo Church over there on the Head, its spire almost invisible against the white sky.
 * 1989, Nancy Chadbourne Maze, The Paul Chadbourn Family of Waterborough, Maine, 1748–1990, Chadbourne Family Association, p. 101:
 * Three churches were in all these old towns as is true today: Congregationalists (Puritan), Baptist, and Methodist. Up until about 1820 the “Congo” church was supported by each town by taxes. Some younger members of their families broke way from the “Congo” and became Baptists or Methodists.
 * 2011, Jim Nichols, Hull Creek: A Novel of the Maine Coast, Down East Books, ISBN 9780892729265, chapter 16:
 * I hear people talking and look between two houses at the Congo Church, where the service has ended and everybody’s coming outside.

title: Citations:Congo


text:
auf dass

Etymology
Spread by Luther, possibly a. Compare 🇨🇬 (which unlike the German is in general popular use).

Conjunction

 * 1)  so that, (in order) that

title: auf dass


text:
Module:fr-verb/documentation

Called by Template:fr-conj-auto. Do not use directly.

title: Module:fr-verb/documentation


text:
bulklike

Adjective

 * 1) Having properties similar to those of bulk material

title: bulklike


text:
interanion

Adjective

 * 1) Between anions

title: interanion


text:
Zwingburg

Etymology
🇰🇲

Pronunciation

Noun

 * 1) stronghold built for the purpose of suppressing the local population

title: Zwingburg


text: Zwingburgen

title: Zwingburgen


text:
countersurface

Noun

 * 1)  A surface over which another moves frictionally

title: countersurface


text:
frictionally

Adverb

 * 1) In terms of friction

title: frictionally


text:
Module:fr-verb/core

local export = {}

local m_conj = require("Module:fr-conj") local m_links = require("Module:links") local lang = require("Module:languages").getByCode("fr") local IPA = function(str) return require("Module:IPA").format_IPA(nil, str) end

local rmatch = mw.ustring.match local rsubn = mw.ustring.gsub

local pref_sufs = {} export.pref_sufs = pref_sufs

-- 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 verb_slot_to_accel(slot) return rsub(slot, "^([a-z_]+)_([123])([sp])$",		function(mood_tense, person, number)			local mood_tense_to_infl = {				["ind_p"] = "pres|indc",				["ind_i"] = "impf|indc",				["ind_ps"] = "phis",				["ind_f"] = "futr",				["cond_p"] = "cond",				["sub_p"] = "pres|subj",				["sub_pa"] = "impf|subj",				["imp_p"] = "impr"			}			return person .. "|" .. number .. "|" .. mood_tense_to_infl[mood_tense]		end	) end

local function map(seq, fun) if type(seq) == "table" then local ret = {} for _, s in ipairs(seq) do			-- Handle stem of the form {"STEM", RESPELLING="RESPELLING"} if type(s) == "table" then s = s[1] end -- 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 add(source, appendix) return map(source, function(s) return s .. appendix end) end

function export.make_ind_p_e(data, stem, stem2, stem3) stem2 = stem2 or stem stem3 = stem3 or stem

data.forms.ind_p_1s = add(stem, "e") data.forms.ind_p_2s = add(stem, "es") data.forms.ind_p_3s = add(stem, "e") data.forms.ind_p_3p = add(stem, "ent") data.forms.ind_p_1p = add(stem2, "ons") -- stem3 is used in -ger and -cer verbs data.forms.ind_p_2p = add(stem3, "ez")

export.make_ind_i(data, stem2, stem3) export.make_ind_ps_a(data, stem2, stem3) export.make_sub_p(data, stem, stem3) export.make_imp_p_ind(data) export.make_ind_f(data, add(stem, "er")) data.forms.ppr = add(stem2, "ant") end

function export.make_ind_p(data, stem, stem2, stem3) stem2 = stem2 or stem stem3 = stem3 or stem2 data.forms.ind_p_1s = add(stem, "s") data.forms.ind_p_2s = add(stem, "s") -- add t unless stem ends in -t (e.g. met), -d (e.g. vend, assied) or -- -c (e.g. vainc). data.forms.ind_p_3s = map(stem, function(s)		return add(s, rmatch(s, "[tdc]$") and "" or "t")	end) data.forms.ind_p_1p = add(stem2, "ons") data.forms.ind_p_2p = add(stem2, "ez") data.forms.ind_p_3p = add(stem3, "ent")

export.make_ind_i(data, stem2) export.make_sub_p(data, stem3, stem2) export.make_imp_p_ind(data) data.forms.ppr = add(stem2, "ant") end

function export.make_ind_i(data, stem, stem2) stem2 = stem2 or stem data.forms.ind_i_1s = add(stem, "ais") data.forms.ind_i_2s = add(stem, "ais") data.forms.ind_i_3s = add(stem, "ait") data.forms.ind_i_1p = add(stem2, "ions") data.forms.ind_i_2p = add(stem2, "iez") data.forms.ind_i_3p = add(stem, "aient") end

function export.make_ind_ps_a(data, stem, stem2) stem2 = stem2 or stem data.forms.ind_ps_1s = add(stem, "ai") data.forms.ind_ps_2s = add(stem, "as") data.forms.ind_ps_3s = add(stem, "a") data.forms.ind_ps_1p = add(stem, "âmes") data.forms.ind_ps_2p = add(stem, "âtes") data.forms.ind_ps_3p = add(stem2, "èrent")

export.make_sub_pa(data, add(stem, "a"))

data.forms.pp = data.forms.pp or add(stem2, "é") end

local function fix_circumflex(val) return rsub(val, "[aiïu]n?%^", {["a^"]="â", ["i^"]="î", ["ï^"]="ï", ["in^"]="în", ["u^"]="û"}) end

function export.make_ind_ps(data, stem) data.forms.ind_ps_1s = add(stem, "s") data.forms.ind_ps_2s = add(stem, "s") data.forms.ind_ps_3s = add(stem, "t") data.forms.ind_ps_1p = map(add(stem, "^mes"), fix_circumflex) data.forms.ind_ps_2p = map(add(stem, "^tes"), fix_circumflex) data.forms.ind_ps_3p = add(stem, "rent")

export.make_sub_pa(data, stem)

data.forms.pp = data.forms.pp or add(stem, "") end

function export.make_ind_f(data, stem) data.forms.ind_f_1s = add(stem, "ai") data.forms.ind_f_2s = add(stem, "as") data.forms.ind_f_3s = add(stem, "a") data.forms.ind_f_1p = add(stem, "ons") data.forms.ind_f_2p = add(stem, "ez") data.forms.ind_f_3p = add(stem, "ont")

export.make_cond_p(data, stem) end

function export.make_cond_p(data, stem) data.forms.cond_p_1s = add(stem, "ais") data.forms.cond_p_2s = add(stem, "ais") data.forms.cond_p_3s = add(stem, "ait") data.forms.cond_p_1p = add(stem, "ions") data.forms.cond_p_2p = add(stem, "iez") data.forms.cond_p_3p = add(stem, "aient") end

function export.make_sub_p(data, stem, stem2) stem2 = stem2 or stem data.forms.sub_p_1s = add(stem, "e") data.forms.sub_p_2s = add(stem, "es") data.forms.sub_p_3s = add(stem, "e") data.forms.sub_p_3p = add(stem, "ent") data.forms.sub_p_1p = add(stem2, "ions") data.forms.sub_p_2p = add(stem2, "iez") end

function export.make_sub_pa(data, stem) data.forms.sub_pa_1s = add(stem, "sse") data.forms.sub_pa_2s = add(stem, "sses") data.forms.sub_pa_3s = map(add(stem, "^t"), fix_circumflex) data.forms.sub_pa_1p = add(stem, "ssions") data.forms.sub_pa_2p = add(stem, "ssiez") data.forms.sub_pa_3p = add(stem, "ssent") end

function export.make_imp_p_ind(data) data.forms.imp_p_2s = map(data.forms.ind_p_2s, function(form)		return rsub(form, "([ae])s$", "%1")	end) -- Need to clone objects when copying forms, otherwise we get duplicated prefixes added in case of -- prefixed verbs. data.forms.imp_p_1p = mw.clone(data.forms.ind_p_1p) data.forms.imp_p_2p = mw.clone(data.forms.ind_p_2p) end

function export.clear_imp(data) data.forms.imp_p_2s = "—" data.forms.imp_p_1p = "—" data.forms.imp_p_2p = "—" end

local function add_prefix_suffix(data, key, val, pref_v, pref_c, pron_v, pron_c, imp, pron_imp, join_imp_dash) if key == "pp" or rmatch(key, "_nolink") then return end local imp_joiner, imp_pron_joiner if join_imp_dash then imp_joiner = "-" imp_pron_joiner = "." else imp_joiner = "" imp_pron_joiner = "" end local pref, suf, pref_pron, suf_pron local function get_pref_suf(v) pref, suf, pref_pron, suf_pron = "", "", "", "" if not rmatch(key, "imp") then if rmatch(v, "^[aeéêiouhywjɑɛœø]") then pref, pref_pron = pref_v, pron_v else pref, pref_pron = pref_c, pron_c end else suf, suf_pron = imp_joiner .. imp, imp_pron_joiner .. pron_imp end end if key == "inf" or key == "ppr" then data.forms[key .. '_nolink'] = map(data.forms[key], function(val)				get_pref_suf(val)				return pref .. val .. suf			end) end data.forms[key] = map(val, function(v)		get_pref_suf(v)		return rsub(pref .. "" .. v .. "" .. suf, "%.h", "h")	end) if data.prons[key] then data.prons[key] = map(data.prons[key], function(v)			get_pref_suf(v)			return pref_pron .. v .. suf_pron		end) end end

pref_sufs["y"] = function(data, key, val) local imp = rmatch(key, "2s") and not rmatch(val, "s$") and "s-y" or "-y" add_prefix_suffix(data, key, val, "y ", "y ", "i.j‿", "i ", imp, ".zi", false) end

pref_sufs["en"] = function(data, key, val) local imp = rmatch(key, "2s") and not rmatch(val, "s$") and "s-en" or "-en" add_prefix_suffix(data, key, val, "en ", "en ", "ɑ̃.n‿", "ɑ̃ ", imp, ".zɑ̃", false) end

pref_sufs["yen"] = function(data, key, val) local imp = rmatch(key, "2s") and not rmatch(val, "s$") and "s-y en" or "-y-en" add_prefix_suffix(data, key, val, "y en ", "y en ", "i.j‿ɑ̃.n‿", "i.j‿ɑ̃ ", imp, ".zi.jɑ̃", false) end

pref_sufs["le"] = function(data, key, val) add_prefix_suffix(data, key, val, "l'", rmatch(key, "2p") and "le or la " or "le ", "l", "lə ", "-le", ".lə", false) end

pref_sufs["la"] = function(data, key, val) add_prefix_suffix(data, key, val, "l'", "la ", "l", "la ", "-la", ".la", false) end

pref_sufs["l"] = function(data, key, val) add_prefix_suffix(data, key, val, "l'", "l'", "l", "l", "-le or -la", ".lə or .la", false) end

pref_sufs["les"] = function(data, key, val) add_prefix_suffix(data, key, val, "les ", "les ", "le.z‿", "le", "-les", ".le", false) end

pref_sufs["l_y"] = function(data, key, val) add_prefix_suffix(data, key, val, "l'y ", "l'y ", "li.j‿", "li ", "-l'y", ".li", false) end

pref_sufs["l_en"] = function(data, key, val) data.aux = "l'en avoir" add_prefix_suffix(data, key, val, "l'en ", "l'en ", "lɑ̃.n‿", "lɑ̃ ", "l'en", "lɑ̃", true) end

pref_sufs["lesen"] = function(data, key, val) data.aux = "les en avoir" add_prefix_suffix(data, key, val, "les en ", "les en ", "le.z‿ɑ̃.n‿", "le.z‿ɑ̃ ", "-les-en", "le.zɑ̃", true) end

pref_sufs["lesy"] = function(data, key, val) add_prefix_suffix(data, key, val, "les y ", "les y ", "le.z‿i.j‿", "le.z‿i ", "-les-y", ".le.zi", false) end

pref_sufs["l_yen"] = function(data, key, val) data.aux = "l'y en avoir" add_prefix_suffix(data, key, val, "l'y en ", "l'y en ", "li.j‿ɑ̃.n‿", "li.j‿ɑ̃ ", "l'y-en", "li.jɑ̃", true) end

pref_sufs["lesyen"] = function(data, key, val) data.aux = "les y en avoir" add_prefix_suffix(data, key, val, "les y en ", "les y en ", "le.z‿i.j‿ɑ̃.n‿", "le.z‿i.j‿ɑ̃ ", "-les-y-en", "le.zi.jɑ̃", true) end

-- Add reflexive prefixes and suffixes to verb forms. KEY is the form to add to, and VAL is the value -- without prefixes and suffixes. PREF_V is the prefix to add to non-imperative forms that begin with a -- vowel, and PREF_C is the corresponding prefix for non-imperative forms beginning with a consonant. -- PRON_V is the prefix to add to the pronunciation of non-imperative forms that begin with a vowel, and -- PRON_C is the corresponding prefix for pronunciations beginning with a consonant. IMP is the suffix to -- add to imperative forms, and PRON_IMP is the corresponding suffix to add to the pronunciation of -- imperative forms. All prefixes and suffixes are added directly, without an intervening space. -- -- Since the prefixes and suffixes vary depending on the person and number, the specified prefixes and -- suffixes should contain "%c" and/or "%v" specs in them. "%c" represents the appropriate pronominal -- form to add before a consonant (or when nothing follows, in the case of suffixes), and "%v" represents -- the corresponding form to add before a vowel. The actual forms substituted depend on both the person -- and number of KEY and the type of prefix (i.e. whether it's a spelled prefix, pronunciation prefix, -- spelled imperative suffix or pronunciation imperative suffix). For example, if key contains "2s" -- (i.e. it represents a second person singular form), a "%v" in a spelled prefix will be replaced with -- "t'" and a "%c" in a pronounced prefix will be replaced with "tə ". Note that it's not always the -- case that %c should occur in a pre-consonant prefix/suffix and correspondingly for %v. For example, -- if the prefix occurs before "en" or "y" you should use %v in both the pre-vowel and pre-consonant -- prefixes. local function add_refl_prefix_suffix(data, key, val, pref_v, pref_c, pron_v, pron_c, imp, pron_imp) local sub_pref_v, sub_pref_c, sub_pron_v, sub_pron_c local sub_imp_v, sub_imp_c, sub_pron_imp_v, sub_pron_imp_c = "", "", "", "" if rmatch(key, "1s") then sub_pref_v, sub_pref_c, sub_pron_v, sub_pron_c = "m'", "me ", "m", "mə " elseif rmatch(key, "2s") then sub_pref_v, sub_pref_c, sub_pron_v, sub_pron_c = "t'", "te ", "t", "tə " sub_imp_v, sub_imp_c, sub_pron_imp_v, sub_pron_imp_c = "t'", "toi", "t", "twa" elseif rmatch(key, "1p") then sub_pref_v, sub_pref_c, sub_pron_v, sub_pron_c = "nous ", "nous ", "nu.z‿", "nu " sub_imp_v, sub_imp_c, sub_pron_imp_v, sub_pron_imp_c = "nous-", "nous", "nu.z", "nu" elseif rmatch(key, "2p") then sub_pref_v, sub_pref_c, sub_pron_v, sub_pron_c = "vous ", "vous ", "vu.z‿", "vu " sub_imp_v, sub_imp_c, sub_pron_imp_v, sub_pron_imp_c = "vous-", "vous", "vu.z", "vu" else sub_pref_v, sub_pref_c, sub_pron_v, sub_pron_c = "s'", "se ", "s", "sə " end local function dosub(spec, dotype) if type(spec) == "table" then local sing, plur = spec[1], spec[2] if rmatch(key, "[12]p") then spec = plur else spec = sing end end spec = rsub(spec, "%%v",			dotype == "pron" and sub_pron_v or			dotype == "imp" and sub_imp_v or			dotype == "pron-imp" and sub_pron_imp_v or			sub_pref_v		) spec = rsub(spec, "%%c",			dotype == "pron" and sub_pron_c or			dotype == "imp" and sub_imp_c or			dotype == "pron-imp" and sub_pron_imp_c or			sub_pref_c		) return spec end add_prefix_suffix(data, key, val, dosub(pref_v), dosub(pref_c), dosub(pron_v, "pron"), dosub(pron_c, "pron"),		dosub(imp, "imp"), dosub(pron_imp, "pron-imp"), true) end

pref_sufs["refl"] = function(data, key, val) data.aux = "s'être" add_refl_prefix_suffix(data, key, val, "%v", "%c", "%v", "%c", "%c", "%c") end

pref_sufs["reflen"] = function(data, key, val) data.aux = "s'en être" add_refl_prefix_suffix(data, key, val, "%ven ", "%ven ", "%vɑ̃.n‿", "%vɑ̃ ", "%ven", "%vɑ̃") end

pref_sufs["refly"] = function(data, key, val) data.aux = "s'y être" add_refl_prefix_suffix(data, key, val, "%vy ", "%vy ", "%vi.j‿", "%vi ", "%vy", "%vi") end

pref_sufs["reflyen"] = function(data, key, val) data.aux = "s'y en être" add_refl_prefix_suffix(data, key, val, "%vy en ", "%vy en ", "%vi.j‿ɑ̃.n‿", "%vi.j‿ɑ̃ ", "%v'y-en", "%vi.jɑ̃") end

pref_sufs["reflle"] = function(data, key, val) data.aux = "se l'être" add_refl_prefix_suffix(data, key, val, "%cl'", "%cle ", "%cl", "%clə ", "le-%c", "lə.%c") end

pref_sufs["refll"] = function(data, key, val) data.aux = "se l'être" add_refl_prefix_suffix(data, key, val, "%cl'", "%cl'", "%cl", "%cl", "le-%c or -la-%c", "lə.%c or .la.%c") end

pref_sufs["reflla"] = function(data, key, val) data.aux = "se l'être" add_refl_prefix_suffix(data, key, val, "%cl'", "%cla ", "%cl", "%cla ", "la-%c", "la.%c") end

pref_sufs["reflles"] = function(data, key, val) data.aux = "se les être" add_refl_prefix_suffix(data, key, val, "%cles ", "%cles ", "%cle.z‿", "%cle ", "les-%c", "le.%c") end

pref_sufs["reflly"] = function(data, key, val) data.aux = "se l'y être" add_refl_prefix_suffix(data, key, val, "%cl'y ", "%cl'y ", "%cli.j‿", "%cli ", "le-%cy or -la-%cy", "lə.%ci or .la.%ci") end

pref_sufs["refllesy"] = function(data, key, val) data.aux = "se les y être" add_refl_prefix_suffix(data, key, val, "%cles y ", "%cles y ", "%cle.z‿i.j‿", "%cle.z‿i ", "les-%cy", "le.%ci") end

function export.link(data) for key, val in pairs(data.forms) do		if type(val) ~= "table" then val = {val} end -- don't destructively modify data.forms[key][i] because it might -- be shared among different keys local newval = {} -- Keep track of forms seen so we don't duplicate them. This must be done before adding accelerators, so we use a separate set. local seen_forms = {} for i, form in ipairs(val) do			if rmatch(form, "—") then form = "—" end if not seen_forms[form] then seen_forms[form] = true if not rmatch(key, "nolink") and form ~= "—" then form = m_links.full_link({term = form, lang = lang,						accel = { form = verb_slot_to_accel(key) }					}) end table.insert(newval, form) end end data.forms[key] = table.concat(newval, " or ") end for key, val in pairs(data.prons) do		if not rmatch(key, "nolink") then if type(val) ~= "table" then val = {val} end -- don't destructively modify data.forms[key][i] because it might -- be shared among different keys local newprons = {} for i, form in ipairs(val) do				if not rmatch(form, "—") then table.insert(newprons, IPA('/' .. form .. '/'))				end end if #newprons > 0 and data.forms[key] ~= "—" then data.forms[key] = data.forms[key] .. ' ' .. table.concat(newprons, " or ") .. ' '			end end end end

-- not sure if it's still used by something so I'm leaving a stub function instead of removing it entirely function export.make_table(data) return m_conj.make_table(data) end

return export

title: Module:fr-verb/core


text:
nanowalker

Noun

 * 1) A nanomachine that moves by walking

title: nanowalker


text:
cirratuliform

Noun

 * 1) Any polychaete worm of the family.

title: cirratuliform


text: cirratuliforms

title: cirratuliforms


text:
semiempirically

Adverb

 * 1) Somewhat empirically

title: semiempirically


text: ubiquinating

title: ubiquinating


text:
naturwissenschaftlich

Adjective

 * 1) scientific, science-oriented

title: naturwissenschaftlich


text: Category:English terms derived from the Proto-Indo-European root *lewgʰ-


text:
periphilin

Noun

 * 1)  Any of a family of proteins associated with the differentiation of skin cells

title: periphilin


text:
Talk:foresave

fore-save
The given citation is the only Google Books result for "to foresave". Equinox ◑ 04:37, 2 March 2015 (UTC)
 * cited and labelled rare, as it is extremely rare yet exists Leasnam (talk) 05:25, 2 March 2015 (UTC)

 * It still seems that some forms (foresaving) are not attestable: is this a rare error by e.g. learners? Equinox ◑ 05:14, 5 March 2015 (UTC)

 * RFV-passed. - -sche (discuss) 21:06, 16 July 2015 (UTC)
 * Hold on. It looks like 6 citations spread over two spellings and two senses. The Christian sense is almost certainly archaic or obsolete and is spread over hyphenated and unhyphenated as the the more recent recoinage. To call both senses saving in advance seems like a stretch. It is like ignoring the difference between and . DCDuring TALK  21:16, 16 July 2015 (UTC)
 * Oh, you're right. In fact, one of the citations was of the noun fore-saving. Of the hyphenated citations, the 1907 Forsyth one is of a religious sense "save (ensure the salvation of) in advance", while the 1937 and 1984 ones seem financial and not particularly intelligible. Of the unhyphenated citations, the 1532 one seems to actually mean "reserved"(?); the 1848 citation is religious; the 1907 citation is financial. So, no sense or spelling has enough citations to pass by our usual standards, although in the discussion of witenagemot some proposed laxer standards. - -sche (discuss) 05:55, 23 July 2015 (UTC)
 * Yeah but all those senses, whether religious, financial, whatever, can be lumped under the general "save" (all senses) qualifier.Same thing we did at Leasnam (talk) 11:01, 23 July 2015 (UTC)
 * I'm not sure the 1532 citation can be lumped into a general sense, even if the other two unhyphenated citations can be: the 1532 citation seems to man something like "reserved"; compare: "I have assigned that my [feoffs] shall [go] to the use of the said John & Anne [...] always except and (reserved | saved in advance) that such landes in Throp Bulmer as be assigned to & for the fyndyng of a preist be not parcell." Does the OED have any citations besides the ones we're already discussing? - -sche (discuss) 22:03, 23 July 2015 (UTC)

 * Meh, kept. - -sche (discuss) 18:49, 16 August 2015 (UTC)

title: Talk:foresave


text:
Talk:deerskin

doeskin
Adjective. Looks unlikely in both cases. Current citation are clearly nominal. 95.144.169.113 12:35, 7 March 2015 (UTC)
 * Both are being used as noun modifiers. The adjective entries (as modifiers) should be transferred to the noun entries. Donnanz (talk) 22:29, 25 March 2015 (UTC)
 * No citations that demonstrate fully adjectival use, though they are, of course, used attributively. DCDuring TALK 13:27, 28 July 2015 (UTC)

 * RFV-failed. - -sche (discuss) 18:52, 16 August 2015 (UTC)

title: Talk:deerskin


text:
Talk:Полет

RFV discussion: April–August 2015
Bulgarian: Paulette. —Μετάknowledge discuss/deeds 20:06, 13 April 2015 (UTC)
 * It's correct. --Anatoli T. (обсудить/вклад) 02:52, 14 April 2015 (UTC)
 * I wasn't asking whether it is correct, but whether it can be cited. I have almost no knowledge of Bulgarian, so I request your help in finding three cites for this entry. —Μετάknowledge discuss/deeds 19:34, 14 April 2015 (UTC)
 * I was hoping you would drop the RFV, if someone confirms it's a correct term. I'm not that keen to keep translations of foreign names into other languages to start looking for citations. On the term itself, in Russian, at least, the name could be Russified a bit and turn into "Полетта" in literature (not necessarily) but if it's an official person, the transliteration would be normally closer to the original. If you know a famous person named Paulette or person from a famous book, you could search for a translation into languages, you added RFV for. --Anatoli T. (обсудить/вклад) 22:16, 14 April 2015 (UTC)
 * It shouldn't be too hard to find the cites on Google Books and link them here if this really is correct. The issue is that we have users that claim something is "correct" even when it cannot be cited literally anywhere, and that's poor lexicography. The only way to deal with that is to go through the RFV process to demonstrate that a word actually passes CFI. —Μετάknowledge discuss/deeds 06:53, 20 April 2015 (UTC)
 * I see your point but it IS hard to find citations for this particular term. Bulgarian Полет is mixed with the Russian, normally spelled "полет" in a running Russian text and as I said, I am not that keen to keep this entry. --Anatoli T. (обсудить/вклад) 23:10, 20 April 2015 (UTC)

 * , would you be able & willing to help with this? —Μετάknowledge discuss/deeds 20:26, 26 April 2015 (UTC)
 * I cannot remember on the spot any work from Bulgarian literature where this name appears. If there is a famous work from Europæan literature with an eponymous personage I could search for a Bulgarian translation in my library (or other available source, if there is a translation) and quote the sentence. The uſer hight Bogorm converſation 17:55, 1 May 2015 (UTC)
 * You don't need to scour your library, you can simply go to and copy-paste three that are in Bulgarian. —Μετάknowledge discuss/deeds 01:51, 2 May 2015 (UTC)
 * As far as I can see, all of them are instances of the noun полет (and not the female proper noun Полет) and searches in google-books are case-insensitive. That is why I resorted to the aforementioned proposal. The uſer hight Bogorm converſation 18:55, 2 May 2015 (UTC)
 * My favorite tool for this is Google advanced search, which makes it possible to limit searches to a particular language. Here is Google books search in Bulgarian for Полет, but it seems to mostly find полет. --Dan Polansky (talk) 20:38, 26 April 2015 (UTC)
 * It appears to be case-insensitive as well, as far as I can infer from your last sentence. The uſer hight Bogorm converſation 18:55, 2 May 2015 (UTC)
 * Looking on Wikipedia, I found Полет Годар and Полет Буржоа. A Google books search looks promising. Could you please confirm that they are actually in Bulgarian? —Internoob 17:13, 9 May 2015 (UTC)
 * Yes, your search is good. They are definitely in Bulgarian (thanks to your params) and various hits are the woman's name ("Paulette"), not the common noun . --Anatoli T. (обсудить/вклад) 14:42, 10 May 2015 (UTC)
 * RFV-passed, then. - -sche (discuss) 07:41, 9 August 2015 (UTC)

title: Talk:Полет


text:
Talk:doeskin

RFV discussion: March–August 2015

 * See Talk:deerskin.

title: Talk:doeskin


text:
Talk:fore-save

RFV discussion: March–August 2015

 * See Talk:foresave.

title: Talk:fore-save


text: セントルシア

title: セントルシア


title: User:Benwing2/test-ru-decl


text: トリニダード・トバゴ

title: トリニダード・トバゴ


text:
di bocca buona

Etymology
lit. 'of good mouth'.

Adjective

 * 1) having a good appetite
 * 2) easy to please

Related terms

 * (can have opposite meaning)

title: di bocca buona


text:
마련되다

Etymology
.

Verb

 * 1)  to be prepared, to be arranged

title: 마련되다


text:
시도하다

Etymology
.

Verb

 * 1)  to try, to attempt

title: 시도하다


text:
적용하다

Etymology
.

Verb

 * 1)  to apply

title: 적용하다


text:
특정하다

Etymology
.

Adjective

 * 1) (to be) particular, specific, certain

title: 특정하다


text:
따라가다

Verb

 * 1) to follow, to go after

title: 따라가다


text: 머물다

title: 머물다


text:
숙이다

Verb

 * 1) to bend, to bow (one's head)

title: 숙이다


text:
지원하다

Etymology
.

Verb

 * 1)  to support, to aid

title: 지원하다


text:
담당하다

Etymology
.

Verb

 * 1)  to take charge, to be in charge

title: 담당하다


text:
벗기다

Verb

 * 1) to take off, to undress
 * 2) to peel, to skin

title: 벗기다


text:
엄격하다

Etymology
.

Adjective

 * 1) (to be) strict, severe, stern, rigid, rigorous

title: 엄격하다


text:
완벽하다

Etymology
.

Adjective

 * 1) (to be) perfect, immaculate, flawless

title: 완벽하다


text:
완전하다

Etymology
.

Adjective

 * 1) (to be) complete, full, perfect

title: 완전하다


text:
분포하다

Etymology
.

Verb

 * 1)  to be distributed

title: 분포하다


text:
해마다

Etymology
.

Adverb

 * 1) every year

title: 해마다


text:
생활하다

Etymology
.

Verb

 * 1)  to live, to live a life

title: 생활하다


text:
솔직하다

Etymology
.

Adjective

 * 1) (to be) honest, frank, direct

title: 솔직하다


text:
앞장서다

Verb

 * 1) to lead, to head, to forerun

title: 앞장서다


text:
요청하다

Etymology
.

Verb

 * 1)  to request, to claim

title: 요청하다


text:
개발되다

Etymology
.

Verb

 * 1)  to be developed

title: 개발되다


text:
대비하다

Etymology 1
.

Verb

 * 1)  to prepare

Etymology 2
.

Verb

 * 1)  to be contrasted, to be compared

title: 대비하다


text:
떨리다

Verb

 * 1) to shake, to tremble

title: 떨리다


text:
자랑스럽다

Etymology
.

Adjective

 * 1) to be proud

title: 자랑스럽다


text:
적용되다

Etymology
.

Verb

 * 1)  to apply

title: 적용되다