Modulo:Parola giapponese
Istruzioni per l'usoQuesto è un modulo scritto in Lua. Le istruzioni che seguono sono contenute nella sottopagina Modulo:Parola giapponese/man (modifica • cronologia)
Sandbox: Modulo:Parola giapponese/Sandbox (modifica•cronologia) • Test: Modulo:Parola giapponese/Test (modifica•cronologia)
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#Giapponese|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