Modulo:Parola giapponese

Da Wikizionario, il dizionario a contenuto aperto.
Jump to navigation Jump to search

Questo modulo costituisce il codice di funzionamento del Template:Parola giapponese e crea, in base ai parametri inseriti in quest'ultimo, le descrizione della pronuncia e trascrizione (hiragana, katakana, romaji) delle parole giapponesi, oltre a generare i link alle coniugazioni e le categorie in corretto ordine alfabetico.

Si compone di una funzione principale, p.parolagiappo (richiamata direttamente nel template) e di due funzioni accessorie (p.wiki, p.cat) che sono utilizzate solo all'interno della funzione principale per abbreviarne il codice (ad es., la funzione p.wiki rende il suo argomento un wikilink). Le sezioni seguenti illustrano il loro funzionamento, iniziando da quella principale.

Funzione p.parolagiappo

È la funzione principale del modulo; interpreta i parametri inseriti nel template (tipo grammaticale, hiragana, katakana, declinazione o coniugazione etc) e in base ad essi costruisce il testo di output e lae relative categorie. La funzione internamente è suddivisibile in sottosezioni identificate nel modulo dai -- commenti; essendo il modulo fortemente commentato dovrebbe essere abbastanza facile comprendere a cosa serve ogni sezione, e in caso modificare (eventualmente bussare all'autore principale).

Funzione p.wiki

La funzione p.wiki (p.wiki(x)) rende il suo argomento, x, un wikilink, con "pipe" alla sezione giapponese. In pratica, nel modulo, scrivere p.wiki(qualcosa) equivale al wikicodice [[qualcosa#Giapponee|qualcosa]].

Funzione p.cat

La funzione p.cat rende il suo argomento, x, una categoria. In pratica, nel modulo, scrivere p.cat(qualcosa) equivale al wikicodice [[Categoria:qualcosa]], e p.cat(qualcosa.. "|".. qualcos'altro) equivale a [[Categoria:qualcosa|qualcos'altro]]


local p = {}
local kanatrasforma = require("Modulo:ja") --questa funzione locale richiama il Modulo:Ja (importato da en.wikt) e viene utilizzata per trasformare i katakana nei corrispondenti hiragana (per ordinare le categorie alfabeticamente per hiragana)
function p.parolagiappo(frame)

-- variabili richiamate nel template
	tipo = frame.args["tipo"]
	hiragana = frame.args["hiragana"] or ""
	katakana = frame.args["katakana"] or ""
	kana = frame.args["kana"] or ""
	romaji = frame.args["romaji"] or ""
	coniugazione = frame.args["coniugazione"] or ""
	declinazione = frame.args["declinazione"] or ""
	k = frame.args["k"] or ""
	s = frame.args["s"] or ""
	catsort = frame.args["catsort"] or ""

-- variabili interne al modulo
	sorthiragana = ""
	categoria = ""
	hiraganadesc = ""
	katakanadesc = ""
	kanadesc = ""
	romajidesc = ""
	conjlink = ""
	conjdesc = ""
	declink = ""
	decdesc = ""
	kyujitai = ""
	shinjitai = ""
	categoria_composti = ""
	kanji = ""
	kanji1 = ""; kanji2 = ""; kanji3 = ""; kanji4 = ""; kanji5 = ""; kanji6 = ""; kanji7 = ""; kanji8 = ""; kanji9 = ""; kanji10 = ""
	
--stringhe "hiraganadesc", "katakanadesc" e "kanadesc", traducono i parametri "hiragana", katakana" e "kana" passato dal template per generare la corrispondente descrizione
	if hiragana > "0" then --se il parametro "hiragana" è definito...
		hiraganadesc = "''hiragana'' ".. p.wiki(hiragana).. ", " --hiraganadesc restituisce la trascrizione in hiragana, passata dal template
	else --se il parametro "hiragana" non è definito...
		hiraganadesc = "" --hiraganadesc si annulla
	end
	if katakana > "0" then --se il parametro "katakana" è definito...
		katakanadesc = "''katakana'' ".. p.wiki(katakana).. ", " --katakanadesc restituisce la trascrizione in katakana, passata dal template
	else --se il parametro "katakana" non è definito...
		katakanadesc = "" --katakanadesc si annulla
	end
	if kana > "0" then --se il parametro "kana" è definito...
		kanadesc = "''kana'' ".. p.wiki(kana).. ", " --kanadesc restituisce la trascrizione in kana, passata dal template
	else --se il parametro "kana" non è definito...
		kanadesc = "" --kanadesc si annulla
	end
	
--stringa "romajidesc", traduce il parametro "romaji" passato dal template per generare la corrispondente descrizione
	if romaji >"0" then --se il parametro "romaji" è definito...
		if tipo == "Suffissi" then --per suffissi e prefissi, il modulo aggiunge in automatico un trattino al romaji, prima e dopo, altrimenti il template sballa se si mette a mano :/
			romajidesc = "''romaji'' ".. p.wiki("-".. romaji) 
		elseif tipo == "Prefissi" then 
			romajidesc = "''romaji'' ".. p.wiki(romaji.. "-") 
		else --per tutti gli altri tipi grammaticali...
		romajidesc = "''romaji'' ".. p.wiki(romaji) --romajidesc restituisce la trascrizione romaji, passata dal template
		end
	else --se il parametro "romaji" non è definito...
		error(" inserire la trascrizione romaji (Hepburn) della parola, con il parametro |romaji = ") --genera un messaggio di errore, la trascrizione romaji è obbligatoria
	end
	
-- stringa "categoria", traduce il parametro "tipo" del template e crea la relativa categoria, ordinandola per ordine alfabetico dopo il pipe "|" in base alla stringa "sorthiragana", che dipende dai parametri "hiragana", katakana" e "kana" del template 
	if tipo > "0" then
		if catsort > "0" then --se il parametro "catsort" è definito
			sorthiragana =  catsort --sorthiragana è uguale al parametro catsort stesso, per forzare l'ordinamento alfabetico 
		else --se catsort non è definito...
			if hiragana > "0" then --se il parametro "hiragana" è definito...
				sorthiragana = hiragana --sorthiragana è uguale al parametro "hiragana"
			else --se il parametro "hiragana" non è definito...
				if katakana > "0" then --se il parametro "katakana" è definito...
				sorthiragana = kanatrasforma.kata_to_hira(katakana) --sorthiragana è uguale al parametro "katakana", ma TRASFORMATO in hiragana con la funzione locale kanatrasforma
				elseif kana > "0" then --se il parametro "kana" è definito...
				sorthiragana = kanatrasforma.kata_to_hira(kana) --sorthiragana è uguale al parametro "kana", ma TRASFORMATO in hiragana con la funzione locale kanatrasforma
				else --se né hiragana, né katakana e né kana sono definiti, vuol dire che la parola è già in kana nel titolo, quindi...
				sorthiragana = kanatrasforma.kata_to_hira(tostring(mw.title.getCurrentTitle())) --sorthiragana è uguale al titolo della pagina, TRASFORMANDO il tutto in hiragana con la funzione locale kanatrasforma
				end
			end
		end
		categoria = p.cat(tipo.. " in giapponese|".. sorthiragana) --genera la categoria, mettendo dopo il pipe "|" la stringa "sorthiragana" generata sopra
	else --se il parametro "tipo" non è definito...
		error(" specificare il tipo grammaticale della parola (verb, agg, sost etc.) con il parametro |tipo = ") --genera un messaggio di errore, indicare la tipologia grammaticale è obbligatorio
	end

	--stringhe "conjlink" e "conjdesc", traducono il parametro "coniugazione" passato dal template per generare il link alla coniugazione e la descrizione corrispondente
	if tipo == "Verbi" then --se la parola è un verbo, dovrebbe avere una coniugazione
		conjlink = " ([[Appendice:Coniugazioni/Giapponese/Verbi/".. tostring(mw.title.getCurrentTitle()).. "|vai alla coniugazione]]) " --genera il link alla declinazione
		if coniugazione > "0" then --se il parametro "coniugazione" è definito...
			conjdesc = "; ''coniugazione [[".. coniugazione.. "]]''" --genera la descrizione della coniugazione verbale
		else --se il parametro "coniugazione" non è definito...
			error("inserire la desinenza della coniugazione verbale con il parametro |coniugazione =") --genera un messaggio di errore, i verbi dovrebbero aver specificata la desinenza della coniugazione
		end
	else --se la parola non è un verbo, non dovrebbe avere una coniugazione
		conjlink = "" 
		conjdesc = "" --conjlink e conjdesc si annullano
	end
	
--stringhe "declink" e "decdesc", traducono il parametro "declinazione" passato dal template per generare il link alla coniugazione e la descrizione corrispondente
	if tipo == "Aggettivi" then --se la parola è un aggettivo, dovrebbe avere una declinazione
		declink = " ([[Appendice:Coniugazioni/Giapponese/Aggettivi/".. tostring(mw.title.getCurrentTitle()).. "|vai alla coniugazione]]) " --genera il link alla declinazione
		if declinazione > "0" then --se il parametro "declinazione" è definito...
			decdesc = "; ''coniugazione in'' [[-".. declinazione.. "]]" --genera la descrizione della coniugazione aggettivale
		else --se il parametro "declinazione" non è definito...
			error("inserire la desinenza della declinazione aggettivale con il parametro |declinazione =") --genera un messaggio di errore, gli aggettivi dovrebbero aver specificata la desinenza della coniugazione
		end
	else --se la parola non è un aggettivo, non dovrebbe avere una declinazione
		declink = "" 
		decdesc = "" --declink e decdesc si annullano
	end
	
--stringhe kyujitai e shinjitai, traducono i parametri "k" e "s" del template, nel caso di parole con caratteri Kyūjitai 
	if k == "si" then --se il parametro "k" è definito...
		kyujitai = "''Kyūjitai kanji'', " --fornisce la relativa descrizione
		if s > "0" then --se il parametro "s" è definito...
			shinjitai = "''variante Shinjitai'': ".. p.wiki(s).. ", " --fornisce il link alla variante shinjitai
		else --se il parametro s non è definito...
			shinjitai = "" --la stringa shinjitai si annulla
		end
	else --se il parametro "k" non è definito...
		kyujitai = "" --la stringa kyujitai si annulla
	end 

--stringa categoria_composti; se il titolo della pagina contiene dei kanji, genera la categoria "composti di 'x' in giapponese"
	local kanji = mw.ustring.gsub((tostring(mw.title.getCurrentTitle())), '([㐀-䶵一-鿌\239\164\128-\239\171\153𠀀-𯨟])々', '%1%1') --trova i kanji nel titolo della pagina
		kanji = mw.ustring.gsub(kanji, '[^㐀-䶵一-鿌\239\164\128-\239\171\153𠀀-𯨟]',   '') -- rimuove i caratteri hiragana o katakana
	if  kanji > "0"  then --se il titolo contiene dei kanji...
		kanji1 = mw.ustring.sub( kanji, 1, 1 ) or ""; kanji2 = mw.ustring.sub( kanji, 2, 2 ) or ""; kanji3 = mw.ustring.sub( kanji, 3, 3 ) or ""; kanji4 = mw.ustring.sub( kanji, 4, 4 ) or ""; kanji5 = mw.ustring.sub( kanji, 5, 5 ) or ""; kanji6 = mw.ustring.sub( kanji, 6, 6 ) or ""; kanji7 = mw.ustring.sub( kanji, 7, 7 ) or ""; kanji8 = mw.ustring.sub( kanji, 8, 8 ) or ""; kanji9 = mw.ustring.sub( kanji, 9, 9 ) or ""; kanji10 = mw.ustring.sub( kanji, 10, 10 ) or ""; --scompone il titolo nei singoli caratteri che lo compongono (FUNZIONA PER COMPOSTI DI FINO A 10 CARATTERI; se ci dovessero essere parole più lunghe va aggiunto kanji11... etc. proseguendo la numerazione, ma è un'eventualità talmente rara che si fa probabilmente prima a inserire manualmente le categorie mancanti nei lemmi)
			if kanji1 == tostring(mw.title.getCurrentTitle()) then --se la parola è composta da un unico kanji...
				categoria_composti_1 = p.cat("Composti di ".. kanji1.. " in giapponese| ") --genera la categoria lasciando uno spazio vuoto dopo il pipe, più elegante ed evita qualche piccolo inconveniente nel caso di kanji con più letture
				categoria_composti_2 = ""; categoria_composti_3 = ""; categoria_composti_4 = ""; categoria_composti_5 = ""; categoria_composti_6 = ""; categoria_composti_7 = ""; categoria_composti_8 = ""; categoria_composti_9 = ""; categoria_composti_10 = "" --...e le altre si annullano
			else --se la parola è composta da più di un solo kanji, genera le categorie corrispondenti, mettendo l'hiragana dopo il pipe
				if kanji10 > "0" then
					categoria_composti_10 = p.cat("Composti di ".. kanji10.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_10 = ""
				end
				if kanji9 > "0" then
					categoria_composti_9 = p.cat("Composti di ".. kanji9.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_9 = ""
				end
				if kanji8 > "0" then
					categoria_composti_8 = p.cat("Composti di ".. kanji8.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_8 = ""
				end
				if kanji7 > "0" then
					categoria_composti_7 = p.cat("Composti di ".. kanji7.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_7 = ""
				end
				if kanji6 > "0" then
					categoria_composti_6 = p.cat("Composti di ".. kanji6.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_6 = ""
				end
				if kanji5 > "0" then
					categoria_composti_5 = p.cat("Composti di ".. kanji5.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_5 = ""
				end
				if kanji4 > "0" then
					categoria_composti_4 = p.cat("Composti di ".. kanji4.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_4 = ""
				end
				if kanji3 > "0" then
					categoria_composti_3 = p.cat("Composti di ".. kanji3.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_3 = ""
				end
				if kanji2 > "0" then
					categoria_composti_2 = p.cat("Composti di ".. kanji2.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_2 = ""
				end
				if kanji1 > "0" then
					categoria_composti_1 = p.cat("Composti di ".. kanji1.. " in giapponese|".. sorthiragana)
				else
					categoria_composti_1 = ""
				end
			end
			categoria_composti = categoria_composti_1.. categoria_composti_2.. categoria_composti_3.. categoria_composti_4.. categoria_composti_5.. categoria_composti_6.. categoria_composti_7.. categoria_composti_8.. categoria_composti_9.. categoria_composti_10 --genera la categoria per ciascuno dei composti della parola, se presenti, mettendo hiraganasort dopo il pipe
	else --se il titolo non contiene kanji...
		categoria_composti = "" --la categoria si annulla
	end

-- infine, incorpora tutte le stringhe precedentemente definite, generando il testo di output
return
conjlink.. declink.. " (".. kyujitai.. shinjitai.. hiraganadesc.. katakanadesc.. kanadesc.. romajidesc.. conjdesc.. decdesc.. ")".. categoria.. categoria_composti
end

-- questa funzione rende il suo argomento un wikilink
function p.wiki(x)
    return "[[" .. x .."#Giapponese".. "|".. x.. "]]"
end
-- questa funzione crea una categoria a partire dal o dai suoi argomenti
function p.cat(x)
	return "[[Categoria:" .. x .. "]]"
end
return p