Mòdul:ca-lema

De Viccionari
Salta a la navegació Salta a la cerca
Icona de documentació de mòdul Documentació del mòdul[mostra] [modifica] [refresca]

A continuació es mostra la documentació transclosa de la subpàgina /ús. [salta a la caixa de codi]


Aquest mòdul presenta un lema en català amb les indicacions de flexió, la sil·labificació i les categories corresponents ordenades. Actualment dóna suport a les plantilles {{ca-nom}} i {{ca-nom-forma}}, {{ca-adj}} i {{ca-adj-forma}}, i {{ca-verb}}. Vegeu la documentació de les plantilles per a la seva utilització.

El mòdul es basa en Mòdul:ca-general per a les funcions generals d'ordenació i sil·lafibicació en català, i en Mòdul:lema pel format general d'un lema. S'invoca amb una única funció flex amb l'argument apropiat. Exemple: {{#invoke:ca-lema|flex|Substantius}}

Genera les formes en femení i en plural a partir d'unes regles vàlides en la majoria de casos. Genera també les etiquetes necessàries per a l'edició accelerada de formes flexionades.

local export = {}
local pos_functions = {}

-- Funció d'entrada per mostrar el lema flexionat, l'única que s'invoca des d'una plantilla
function export.flex(frame)
	local args = frame:getParent().args
	pagename = args.pagename
	if not pagename or pagename == "" then
		pagename = mw.title.getCurrentTitle().subpageText
	end
	
	local data = {lang = "ca", sc = "Latn", heads = {}, genders = {}, inflections = {}, categories = {}}
	local lema = args.lema; if lema == "" then lema = nil end
	table.insert(data.heads, lema)
	local isLemma = frame.args['forma'] == nil and true or nil
	
	local poscat = frame.args[1] or error("Falta especificar la categoria lèxica com a primer paràmetre.")
	if pos_functions[poscat] then
		pos_functions[poscat].func(args, data, isLemma)
	else
		table.insert(data.categories, poscat .. " en català")
	end
	if args.cat and args.cat ~= "" then
		table.insert(data.categories, args.cat)
	end
	
	if args.bot then
		return require("Mòdul:lema").make_bot_list(data.inflections)
	else
		if lema == nil and not mw.ustring.find(pagename, "[^ ]+ [^ ]+") then
			table.insert(data.heads, require('Module:ca-general').sil(pagename))
		end
		return require("Mòdul:lema").full_headword(data)
	end
end

-- Informació de flexió per a substantius
pos_functions["Substantius"] = {func = function(args, data, isLemma)

	-- Codis gènere-nombre:
	--	"m", "f", "mf"
	--	"m-p", "f-p", "mf-p" pluralia tantum
	--	"m-s", "f-s", "mf-s" només o normalment en singular
	--	"m-i", "f-i", "mf-i" invariable en nombre
	--	"m-?", "f-?", "mf-?" sense plural conegut
	--	"mp", "fp", "mfp"    flexionats en plural

	local genere = args[1] or ""
	local plural = args[2] or args.p
	local plural2 = args.p2 -- si està buit, l'anul·la
	local fem = args["f"]
	local tipus = nil
	local gn = mw.text.split(genere, "-")
	if #gn > 1 then
		genere = gn[1]
		tipus = gn[2]
	end
	if genere == "" then
		table.insert(data.genders, "?")
	else
		local generes = mw.text.split(genere, "")
		table.insert(data.genders, table.concat(generes, "-")) -- conversió a "m", "f", "m-f", "m-p", "f-p", "m-f-p"
	end
	
	-- Categoria gramatical
	if mw.ustring.find(pagename, "[^ ]+ [^ ]+") then
		if isLemma then
			table.insert(data.categories, "Locucions nominals en català")
		else
			table.insert(data.categories, "Formes de locucions nominals en català")
		end
	elseif genere == "mf" then
		table.insert(data.categories, "Substantius femenins i masculins en català")
	elseif genere == "mfp" then
		table.insert(data.categories, "Formes de substantius en plural en català")
	elseif genere == "m" then
		table.insert(data.categories, "Substantius masculins en català")
	elseif genere == "mp" then
		table.insert(data.categories, "Formes de substantius en plural en català")
	elseif genere == "f" then
		if isLemma then
			table.insert(data.categories, "Substantius femenins en català")
		else
			table.insert(data.categories, "Formes de substantius en femení en català")
		end
	elseif genere == "fp" then
		table.insert(data.categories, "Formes de substantius en plural en català")
	else
		if isLemma then
			table.insert(data.categories, "Substantius en català")
		else
			table.insert(data.categories, "Formes de substantius en català")
		end
	end
	
	-- Plural
	if genere == "mp" or genere == "fp" or genere == "mfp" then
		local sing, pAlt = forma_plural_alt(pagename)
		plural2 = plural2 or pAlt
		if plural2 ~= "" then
			table.insert(data.inflections, {label = "alternatiu", plural2, accel = "plural-form-of gender-"..string.sub(genere, 1, -2).." origin-"..sing})
		end
	elseif tipus ~= "?" then
		if tipus == "i" then
			table.insert(data.inflections, {label = "plural invariable"})
			table.insert(data.categories, "Substantius amb plural invariable en català")
		elseif tipus == "p" then
			table.insert(data.inflections, {label = "plurale tantum"})
			table.insert(data.categories, "Substantius pluralia tantum en català")
		elseif tipus == "s" then
			if plural ~= nil then
				table.insert(data.inflections, {label = "normalment en singular"})
			else
				table.insert(data.inflections, {label = "només en singular"})
			end
			-- table.insert(data.categories, "Substantius singularia tantum en català")
		end
		if plural ~= nil or tipus == nil then
			local infl_parts = {label = "plural", accel = "plural-form-of gender-" .. genere}
			local p, p2 = export.forma_plural_nominal(pagename)
			if plural == "" or plural == nil then
				plural = p
			end
			plural2 = plural2 or p2
			table.insert(infl_parts, plural)
			if plural2 ~= "" then
				table.insert(infl_parts, plural2)
				if not mw.title.new(plural2).exists then
					table.insert(data.categories, "Termes en català amb flexions a crear")
				end
			end
			table.insert(data.inflections, infl_parts)
			if not mw.title.new(plural).exists then
				table.insert(data.categories, "Termes en català amb flexions a crear")
			end
		end
	end
	
	-- Femení
	if fem == "" then -- demanat però no definit
		fem = export.forma_femenina(pagename)
	end
	if fem then
		table.insert(data.inflections, {label = "femení", fem, accel = "femenina-form-of gender-f"})
		if not mw.title.new(fem).exists then
			table.insert(data.categories, "Termes en català amb flexions a crear")
		end
	end
end
}

-- Informació de flexió per a adjectius
pos_functions["Adjectius"] = {func = function(args, data, isLemma)
	-- Gènere: m (masculí), i (invariable)
	-- Gènere flexionats: f, mp, fp, ip
	local genere = args[1]; if genere == "" then genere = nil end
	local locucio = mw.ustring.find(pagename, "[ ']")
	if not genere then
		if locucio then
			genere = "loc"
		elseif string.find(pagename, "a$") then
			genere = "i"
		else
			genere = "m"
		end
	end
	genere = string.gsub(genere, "mf", "i")
	genere = string.gsub(genere, "([^%-])p$", "%1%-p") -- conversió a "m-p", "f-p", "i-p"
	table.insert(data.genders, genere)
	
	-- Plurals:
	--	p= plural masculí o plural de gènere invariable
	--	p2= segon plural masculí o invariable
	--	pf = plural femení

	local p, p2 = export.forma_plural(pagename, genere)
	local plural = args.p or p
	local plural2 = args.p2 -- nil: a generar, "" no mostrar
	local plural_fem = args.pf -- nil: a generar, "" no mostrar

	-- Gènere invariable
	if genere == "i" then
		if locucio then
			table.insert(data.categories, "Locucions adjectivals en català")
		else
			table.insert(data.categories, "Adjectius en català")
			table.insert(data.categories, "Adjectius invariables en català")
		end
		if plural_fem == nil then plural_fem = p2 end
		if plural2 == nil then plural2 = p2 end
		if plural_fem ~= "" then
			table.insert(data.inflections, {label = "plural masculí", accel = "plural-form-of gender-m", plural})
			table.insert(data.inflections, {label = "plural femení", accel = "plural-form-of gender-f", plural_fem})
			if not mw.title.new(plural).exists or not mw.title.new(plural_fem).exists then
				table.insert(data.categories, "Termes en català amb flexions a crear")
			end
		elseif plural2 ~= "" then
			table.insert(data.inflections, {label = "plural", accel = "plural-form-of gender-i", plural, plural2})
			if not mw.title.new(plural).exists or not mw.title.new(plural2).exists then
				table.insert(data.categories, "Termes en català amb flexions a crear")
			end
		else
			table.insert(data.inflections, {label = "plural", accel = "plural-form-of gender-i", plural})
			if not mw.title.new(plural).exists then
				table.insert(data.categories, "Termes en català amb flexions a crear")
			end
		end
	-- Doble gènere
	elseif genere == "m" then
		if locucio then
			table.insert(data.categories, "Locucions adjectivals en català")
		else
			table.insert(data.categories, "Adjectius en català")
		end
		local fem = args.f or export.forma_femenina(pagename)
		if plural2 == nil then plural2 = p2 end
		local pf, pf2 = export.forma_plural(fem, "")
		if plural_fem == nil then plural_fem = pf end
		table.insert(data.inflections, {label = "femení", accel = "femenina-form-of gender-f", fem})
		if plural_fem == plural then
			table.insert(data.inflections, {label = "plural invariable", accel = "plural-form-of gender-i", plural})
		else
			if plural2 == "" then
				table.insert(data.inflections, {label = "plural masculí", accel = "plural-form-of gender-m", plural})
			else
				table.insert(data.inflections, {label = "plural masculí", accel = "plural-form-of gender-m", plural, plural2})
				if not mw.title.new(plural2).exists then
					table.insert(data.categories, "Termes en català amb flexions a crear")
				end
			end
			table.insert(data.inflections, {label = "plural femení", accel = "plural-form-of gender-f origin-" .. fem, plural_fem})
			if not mw.title.new(plural_fem).exists then
				table.insert(data.categories, "Termes en català amb flexions a crear")
			end
		end
		if not mw.title.new(fem).exists or not mw.title.new(plural).exists then
			table.insert(data.categories, "Termes en català amb flexions a crear")
		end
	-- Formes flexionades
	elseif genere == "f" then
		table.insert(data.categories, "Formes d'adjectius en femení en català")
		local pf, pf2 = export.forma_plural(pagename, "")
		if plural_fem == nil then plural_fem = pf end
		table.insert(data.inflections, {label = "plural", accel = "plural-form-of gender-f", plural_fem})
		if not mw.title.new(plural_fem).exists then
			table.insert(data.categories, "Termes en català amb flexions a crear")
		end
	elseif genere == "m-p" then
		table.insert(data.categories, "Formes d'adjectius en plural en català")
		local sing, pAlt = forma_plural_alt(pagename)
		if plural2 == nil then plural2 = pAlt end
		if plural2 ~= "" then
			table.insert(data.inflections, {label = "alternatiu", accel = "plural-form-of gender-m origin-" .. sing, plural2})
			if not mw.title.new(plural2).exists then
				table.insert(data.categories, "Termes en català amb flexions a crear")
			end
		end
	elseif genere == "f-p" then
		table.insert(data.categories, "Formes d'adjectius en plural en català")
	elseif genere == "i-p" then
		table.insert(data.categories, "Formes d'adjectius en plural en català")
	elseif genere == "loc" then
		table.insert(data.categories, "Locucions adjectivals en català")
	end
	
end
}

-- Flexió de numerals: cardinals invariables amb possible femení, altres com adjectius
pos_functions["Numerals"] = {func = function(args, data, isLemma)
	local genere = args[1] or "i"
	local fem = args.f
	local fem2 = args.f2
	local plural = args.p
	local plural2 = args.p2
	local plural_fem = args.pf
	
	table.insert(data.categories, "Numerals en català")
	
	-- femení
	fem = fem or export.forma_femenina(pagename)
	if genere == "m" or (genere == "i" and args.f) then
		table.insert(data.genders, "m")
		table.insert(data.inflections, {label = "femení", fem, fem2})
	else
		table.insert(data.genders, genere)
	end
	
	-- plurals
	if genere == "m" then
		local p, p2 = export.forma_plural(pagename, genere)
		plural = plural or p
		if plural2 == nil and p2 ~= "" then plural2 = p2 end
		local pf, pf2 = export.forma_plural(fem, "")
		plural_fem = plural_fem or pf
		if plural_fem == plural then
			table.insert(data.inflections, {label = "plural", plural})
		else
			table.insert(data.inflections, {label = "plural masculí", plural, plural2})
			table.insert(data.inflections, {label = "plural femení", plural_fem})
		end
	end
	
end
}

-- Informació de verbs
pos_functions["Verbs"] = {func = function(args, data, isLemma)
	local tipus = args[1] or ""
	local titol = pagename
	formaPron = titol:find("%-se") or titol:find("re's") or titol:find("s'hi") or titol:find("s'")
	locucio = titol:find(" ")
	
	if locucio then
		table.insert(data.categories, "Locucions verbals en català")
	elseif formaPron then
		table.insert(data.categories, "Verbs pronominals en català")
	else
		table.insert(data.categories, "Verbs en català")
	end

	if formaPron and not tipus:find("p") then
		tipus = tipus .. "p"
	elseif not locucio and tipus == "" then
		tipus = "?"
	end
	tipus = string.gsub(tipus, "[^atipm-]", "?")
	if tipus:find("?") then
		table.insert(data.categories, "Manteniment plantilla ca-verb")
	end
	
	if tipus ~= "" then
		local totsTipus = mw.text.split(tipus, "-")
		for i, tipusx in ipairs(totsTipus) do
			local tipusPart = mw.text.split(tipusx, "")
			local gendersPart = {}
			for ii, tipusPartx in ipairs(tipusPart) do
				if tipusPartx ~= "?" then tipusPartx = "v" .. tipusPartx end
				table.insert(gendersPart, tipusPartx)
			end
			table.insert(data.genders, table.concat(gendersPart, "-"))
		end
	end
	
	local flexPron = args["p"]; if flexPron == "" then flexpron = nil end
	local defectiu = args.defectiu; if defectiu ~= nil then defectiu = true end
	
	if defectiu then
		table.insert(data.inflections, {label = "defectiu"})
	end
	
	if not flexPron and tipus:find("p") and not formaPron then
		flexPron = string.gsub(titol, "re$", "re's")
		flexPron = string.gsub(flexPron, "r$", "r-se")
	end
	if flexPron then
		table.insert(data.inflections, {label = "pronominal", flexPron})
	end
	
	local flexImper = args["m"]; if flexImper == "" then flexImper = nil end
	if flexImper then
		table.insert(data.inflections, {label = "impersonal", flexImper})
	end
	local flexIntr = args["i"]; if flexIntr == "" then flexIntr = nil end
	if flexIntr then
		table.insert(data.inflections, {label = "intransitiu", flexIntr})
	end
		
end
}

-- Forma femenina
-- TODO: locucions com el plural
function export.forma_femenina(base)
	-- Usat per Mòdul:ca-verb
	local fem = base
	fem = mw.ustring.gsub(fem, "à$", "ana")
	fem = string.gsub(fem, "[eo]$", "a")
	fem = mw.ustring.gsub(fem, "[èé]$", "ena")
	fem = mw.ustring.gsub(fem, "([^gq][aeou])í$", "%1ïna")
	fem = mw.ustring.gsub(fem, "í$", "ina")
	fem = mw.ustring.gsub(fem, "[òó]$", "ona")
	fem = string.gsub(fem, "([aio])u$", "%1va")
	fem = mw.ustring.gsub(fem, "ú$", "una")
	if mw.ustring.find(fem, "g$") then
		fem = string.gsub(fem, "leg$", "loga")
		fem = string.gsub(fem, "oig$", "oja")
	elseif mw.ustring.find(fem, "[ei]n$") and not mw.ustring.find(fem, "[àèéíòóú]") then
		fem = mw.ustring.gsub(fem, "a([^aeio]+[ei]n)$", "à%1a")
		fem = mw.ustring.gsub(fem, "e([^aeio]+[ei]n)$", "è%1a")
		fem = mw.ustring.gsub(fem, "i([^aeio]+[ei]n)$", "í%1a")
		fem = mw.ustring.gsub(fem, "o([^aeio]+[ei]n)$", "ò%1a")
		fem = mw.ustring.gsub(fem, "u([^aeio]+[ei]n)$", "ú%1a")
	elseif mw.ustring.find(fem, "s$") then
		fem = mw.ustring.gsub(fem, "[aà]s$", "assa")
		fem = mw.ustring.gsub(fem, "ès$", "esa")
		fem = mw.ustring.gsub(fem, "és$", "essa")
		fem = mw.ustring.gsub(fem, "ís$", "issa")
		fem = mw.ustring.gsub(fem, "[oò]s$", "ossa")
		fem = mw.ustring.gsub(fem, "ós$", "osa")
		fem = mw.ustring.gsub(fem, "ús$", "usa")
	end
	fem = mw.ustring.gsub(fem, "([aiïu])t$", "%1da")
	fem = mw.ustring.gsub(fem, "a(%l)i$", "à%1ia")
	fem = mw.ustring.gsub(fem, "i(%l)i$", "í%1ia")
	if fem == base and not string.find(base, "a$") then
		fem = base .. "a"
	end
	
	return fem
end

-- Forma plural
function export.forma_plural_nominal(lema)
	if lema:find("[^ ]+ [^ ]+") then
		local preposicions = {" a ", " al ", " amb ", " com ", " contra ", " des ", " d'", " del ", " dels ", " de ",
				" dintre ", " en ", " endavant", " enrere", " entre ",
				" fora ", " per ", " pel ", " pels ", " sense ", " sobre ", " sota "}
		for i, prep in ipairs(preposicions) do
			offset = mw.ustring.find(lema, prep, 1, true)
			if offset then
				local part1 = mw.ustring.sub(lema, 1, offset-1)
				local part2 = mw.ustring.sub(lema, offset)
				local plural1, plural2 = export.forma_plural_nominal(part1)
				return plural1 .. part2, plural2 .. (plural2=="" and "" or part2)
			end
		end
		local plurals1 = {}
		local plurals2 = {}
		for part in mw.text.gsplit(lema, " ", true) do
			local partplural1, partplural2 = export.forma_plural(part,"")
			table.insert(plurals1, partplural1)
			table.insert(plurals2, partplural2=="" and partplural1 or partplural2)
		end
		local plural1 = table.concat(plurals1, " ")
		local plural2 = table.concat(plurals2, " ")
		return plural1, plural2==plural1 and "" or plural2
	else
		return export.forma_plural(lema,"")
	end
end

function export.forma_plural(mot, genere)
	-- doble plural
	if string.find(mot, "s[cpt]$") or string.find(mot, "xt$") then
		return mot .. "s", mot .. "os"
	elseif string.find(mot, "ig$") and mot ~= "puig" and mot ~= "raig" then
		return mot .. "s", string.gsub(mot, "ig$", "jos")
	elseif genere == "i" and mw.ustring.find(mot, "[aio]ç$") then -- model feliç
		return mot .. "os", mw.ustring.gsub(mot, "ç$", "ces")
	elseif genere == "i" and mot:find("x$") then -- model circumflex
		return mot .. "os", mot .. "es"
	end
	local plural = mot
	-- a -> es, amb canvis morfològics
	if string.find(mot, "a$") then
		plural = string.gsub(plural, "ca$", "ques")
		plural = string.gsub(plural, "ga$", "gues")
		plural = mw.ustring.gsub(plural, "ça$", "ces")
		plural = string.gsub(plural, "ja$", "ges")
		plural = mw.ustring.gsub(plural, "([gq])ua$", "%1ües")
		if plural == mot then plural = string.gsub(mot, "a$", "es") end
	-- vocal accentuada + n -> sense accent + ns
	elseif mw.ustring.find(mot, "[àéèíóòú]n?$") then
		plural = mw.ustring.gsub(plural, "à$", "ans")
		plural = mw.ustring.gsub(plural, "[èé]n?$", "ens")
		plural = mw.ustring.gsub(plural, "([^g][aeou])í$", "%1ïns")
		plural = mw.ustring.gsub(plural, "ín?$", "ins")
		plural = mw.ustring.gsub(plural, "[òó]n?$", "ons")
		plural = mw.ustring.gsub(plural, "ú$", "uns")
		if plural == mot then plural = mot .. "s" end
	-- en/in -> accent ... + ens/ins
	elseif mw.ustring.find(mot, "[ei]n$") and not mw.ustring.find(mot, "[àèéíòóú]") then
		plural = mw.ustring.gsub(plural, "a([^aeio]+[ei]n)$", "à%1s")
		plural = mw.ustring.gsub(plural, "e([^aeio]+[ei]n)$", "è%1s")
		plural = mw.ustring.gsub(plural, "i([^aeio]+[ei]n)$", "í%1s")
		plural = mw.ustring.gsub(plural, "o([^aeio]+[ei]n)$", "ò%1s")
		plural = mw.ustring.gsub(plural, "u([^aeio]+[ei]n)$", "ú%1s")
		if plural == mot then plural = mot .. "s" end
	-- s -> s(s)os
	elseif string.find(mot, "s$") then
		if not mw.ustring.find(mot, "[aàeèéiíïoòóuú].*[eou]s$") then -- invariables excepte monosíl·labs
			plural = mw.ustring.gsub(plural, "[oò]s$", "ossos") -- -os ha de ser el primer
			plural = mw.ustring.gsub(plural, "[aà]s$", "assos")
			plural = mw.ustring.gsub(plural, "és$", "essos")
			plural = mw.ustring.gsub(plural, "[eè]s$", "esos")
			plural = mw.ustring.gsub(plural, "oís$", "oïssos")
			plural = mw.ustring.gsub(plural, "([^gq][au])ís$", "%1ïsos")
			plural = mw.ustring.gsub(plural, "ís$", "issos")
			plural = mw.ustring.gsub(plural, "ós$", "osos")
			plural = mw.ustring.gsub(plural, "ús$", "usos")
			plural = mw.ustring.gsub(plural, "us$", "ussos")
			if plural == mot then plural = mot .. "os" end
		end
	else
		plural = mw.ustring.gsub(plural, "([çxz])$", "%1os")
		if plural == mot then
			plural = mot .. "s"
		end
	end
	return plural, ""
end

-- Forma plural alternativa
function forma_plural_alt(mot)
	local sing = ""
	local pAlt = ""
	if string.find(mot, "s[cpt]os$") or string.find(mot, "xtos$") then
		sing = string.gsub(mot, "os$", "")
		pAlt = string.gsub(mot, "os$", "s")
	elseif string.find(mot, "s[cpt]s$") or string.find(mot, "xts$") then
		sing = string.gsub(mot, "s$", "")
		pAlt = string.gsub(mot, "s$", "os")
	elseif string.find(mot, "jos$") then
		sing = string.gsub(mot, "jos$", "ig")
		pAlt = string.gsub(mot, "jos$", "igs")
	elseif string.find(mot, "igs$") then
		sing = string.gsub(mot, "s$", "")
		pAlt = string.gsub(mot, "igs$", "jos")
	end
	return sing, pAlt
end
	
-- Funcions exportables per a proves a Mòdul:ca-general/ús
function export.fem(frame)
	return export.forma_femenina(frame.args[1])
end
		
function export.plural(frame)
	local p, p2 = export.forma_plural_nominal(frame.args[1])
	return p .. ' ' .. p2
end
	
return export