Modulo:Sandbox/Barbaking/Barbabot

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

man - modifica

Questo modulo in sandbox è utilizzato dal Barbabot per la creazione delle forme flesse latine, permettendo di gestire correttamente gli accenti di lūnga e di brĕve.

è pensato per essere substato durante la scrittura automatica delle voci flesse.

  • p.linknosill genera la radice della parola che viene linkata, senza divisione in sillabe, senza accenti: riceve un parametro del tipo mā9tĕr e lo trasforma in mater - è il codice di Utente:Barbaking/Linknosill
  • p.nosill genera la radice della parola che appare nel link visualizzato, senza divisione in sillabe ma con gli accenti: riceve un parametro del tipo mā9tĕr e lo trasforma in mātĕr - è il codice di Utente:Barbaking/Nosill
  • p.sill genera la sillabazione nella sezione apposita, dividendo tra loro le sillabe con i pipe |: riceve un parametro del tipo mā9tĕr e lo trasforma in mā | tĕr - è il codice di Utente:Barbaking/Sill
  • p.pronclass genera la pronuncia CLASSICA nella sezione apposita, trasformando il testo in alfabeto IPA: riceve un parametro del tipo mā9tĕr e lo trasforma in ˈmaː.ter - è il codice di Utente:Barbaking/Pronclass
  • p.proneccl genera la pronuncia ECCLESIASTICA nella sezione apposita, trasformando il testo in alfabeto IPA: riceve un parametro del tipo mā9tĕr e lo trasforma in ˈma.ter - è il codice di Utente:Barbaking/Proneccl

fun fact: nell'ambito del modulo si usano i "9" per dividere le sillabe, perché la sintassi mediawiki sbrocca se si utilizzano direttamente i |, visto che li interpreta come inizio di un nuovo parametro...


local p = {}

function p.linknosill(frame)
	local noaccenti = require("Modulo:Latino") --richiama il [[Modulo:Latino]], da utilizzarsi sotto per eliminare gli accenti
	local dp={ -- funzione che elimina i 9 (che dividono le sillabe tra loro)
	['9'] = ''
	};
	radice = frame.args[1] --l'argomento passato dal template, ad es. mā9tĕr
	radicelink = noaccenti.noaccenti(radice) --l'argomento senza accenti: ma9ter
	switch = (mw.ustring.gsub(radicelink, '.', dp)) --l'argomento senza accenti e senza divisione in sillabe: mater
	return switch
	end

function p.nosill(frame)
	local nobrevi = require("Modulo:Latino") --richiama il [[Modulo:Latino]], da utilizzarsi sotto per eliminare gli accenti
	local dp={ -- funzione che elimina i 9 (che dividono le sillabe tra loro)
	['9'] = ''
	};
	radice = frame.args[1] --l'argomento passato dal template, ad es. mā9tĕr
	radicelunga = nobrevi.nobrevi(radice) --l'argomento senza accenti di lunga: mā9ter
	switch = (mw.ustring.gsub(radicelunga, '.', dp)) --l'argomento, con accenti di lunga ma senza accenti di breve e divisione in sillabe: māter
	return switch
	end
	
function p.sill(frame)
	radice = frame.args[1] --l'argomento passato dal template, ad es. mā9tĕr
	local dg={ --funzione che trasforma le vocali senza accenti in vocali brevi
	['a']='ă',
	['e']='ĕ',
	['i']='ĭ',
	['o']='ŏ',
	['u']='ŭ',
	};
	switch = (mw.ustring.gsub(radice, '.', dg)) --aggiunge il simbolo di breve in tutte le vocali non lunghe
	--ripristina i dittonghi
	switch = (string.gsub(switch,"ăĕ","ae"))
	switch = (string.gsub(switch,"ŏĕ","oe"))
	switch = (string.gsub(switch,"ăŭ","au"))
	local dp={ -- funzione che trasforma i 9 (che dividono le sillabe tra loro) in pipe |, che sono i divisori utilizzati per convenzione nella sezione {{-sill-}} di wiktionary
	['9'] = ' | '
	};
	switch = (mw.ustring.gsub(switch, '.', dp)) --l'argomento diviso in sillabe dai pipe: mā | tĕr
	return switch
	end
	
function p.pronclass(frame)
	--questa funzione gestisce la pronuncia CLASSICA; trasforma la parola che viene inserita nella pronuncia IPA: mā9tĕr -> ˈmaː.ter
	radice = frame.args[1] --l'argomento passato dal template, ad es. mā9tĕr
	tipo = frame.args[2] or nil
	
	--per prima cosa sostituisce, a scaglioni, tutte le lettere o gruppi di lettere che lo necessitano. il processo è a tappe, ogni tappa sostituisce qualcosa
	--i 9 che separano le sillabe vanno tenuti fino alla fine, perché serviranno. 
	
	--trasforma in minuscole tutte le lettere della radice (per evitare problemi in caso di nomi propri)
	pron = mw.ustring.lower(radice)
	
	--risolve i dittonghi: coe9pi -> coe̯9pi; lae9tus -> lae̯9tus
	pron = (string.gsub(pron,"ae","ae̯"))
	pron = (string.gsub(pron,"oe","oe̯"))
	pron = (string.gsub(pron,"au","au̯"))
	
	--risolve le sillabe brevi e lunghe: mā9tĕr -> maː9ter
local voc={ 
	['ā']='aː',['ă']='a',
	['ē']='eː',['ĕ']='e',
	['ī']='iː',['ĭ']='i',
	['ō']='oː',['ŏ']='o',
	['ū']='uː',['ŭ']='u',
	['ȳ']='yː',
	};
	pron = (mw.ustring.gsub(pron, '.', voc))
	--risolve il gruppo "9x": vi9xi -> vik9si
local ics={ 
	["9x"] = 'k9s'
	};
	pron = (string.gsub(pron,"%d%a",ics))
	--risolve i dittonghi in i-: iu9bi9lo -> ju9bi9lo
local jay={ 
	["iu"] = 'ju', ["ia"] = 'ja', ["ie"] = 'je', ["io"] = 'jo',
	};
	pron = (string.gsub(pron,"%a%a",jay))
	--risolve i dittonghi in i- (che sono ora diventati in j-) a cavallo di sillaba: ba9ju9lus -> baj9ju9lus
local jays={ 
	["9ju"] = 'j9ju', ["9ja"] = 'j9ja', ["9je"] = 'j9je', ["9jo"] = 'j9jo',
	};
	pron = (string.gsub(pron,"%d%a%a",jays))
	--risolve il gruppo "qu-": qua9si -> kʷa9si
local qua={ 
	["qu"] = 'kʷ'
	};
	pron = (string.gsub(pron,"%a%a",qua))
	--risolve varie consonanti: vī9vō -> wiː9woː; că9dō -> ka9doː eccetera
local cons={ 
	["v"] = 'w', ["c"] = 'k', ["x"] = 'ks', ['h'] = 'ʰ'
	};
	pron = (mw.ustring.gsub(pron, '.', cons))
	
	--FINITE LE SOSTITUZIONI, bisogna iniziare a ragionare sull'accento, ovvero far venir fuori da mā9tĕr -> ˈmaː9ter e da a9dae9quō -> aˈdae̯.kʷoː
	--per prima cosa bisogna sapere di quante sillabe è composta la parola; per fortuna le sillabe sono separate da "9"
	pron = "9".. pron --aggiunge un "9" a inizio parola, per indicare la prima sillaba: mā9tĕr -> 9maː9ter
	nove = (string.gsub(pron,"%D","")) --elimina tutto tranne i numeri: 9maː9ter -> 99; 9ju9bi9lo -> 999; 9lau9da9vis9sent -> 9999
	nsill = tonumber(string.len(nove)) --conta quanto è lunga la stringa così creata; è in byte, ma per le cifre 1 cifra = 1 byte (spero): 9 -> 1; 99 -> 2; 999 -> 3; 9maː9ter -> 2

	--adesso che abbiamo il numero di sillabe, si vede dove casca l'accento
	--se la parola ha 1 o 2 sillabe, l'accento casca per forza sulla prima (almeno in questo il latino è comodo)
	if nsill < 3 then
		pron = (string.gsub(pron,"9","ˈ",1))
	
	--se invece la parola ha più di tre sillabe, bisogna invece andare a vedere se è piana (accento sull'ultima sillaba) o sdrucciola (accento sulla penultima sillaba); in latino non esistono né bisdrucciole né tronche
	--la discriminante è la penultima sillaba; in latino una parola è piana se questa:
		--a) termina per consonante, a prescindere dalla quantità della vocale: lau.dàn.tes
		--b) contiene una vocale lunga:  ha.bē.re -> ha.bè.re; di.cĕ.re -> dì.ce.re oppure un dittongo: a.dae.quo -> a.dàe.quo
			--c'è un'altra regola che dice che la parola è piana se termina con una enclitica (-cum, -que etc.), tipo "fratrèmque", ma non ci interessa ai fini di questo modulo
	else		
	--si va quindi a vedere che succede nella penultima sillaba
	-- NB: in tutta questa sezione si usa la stringa "radice", cioé la parola così come viene passata dal template, senza le sostituzioni fatte alla stringa "pron"; quindi le ā sono ancora ā, le ĕ ancora ĕ eccetera
		nsost = tonumber(nsill-2) --il numero di sillabe della parola meno due, ovvero meno l'ultima e la penultima
		fineparola = (string.gsub(radice,".-9","",nsost)) --elimina tutte le sillabe tranne le ultime due: lau9da9vis9sent = vis9sent
		
		--cerca una consonante a fine sillaba
		if string.find(fineparola,"b9") or string.find(fineparola,"c9") or string.find(fineparola,"d9") or string.find(fineparola,"f9") or string.find(fineparola,"g9") or string.find(fineparola,"l9") or string.find(fineparola,"m9") or string.find(fineparola,"n9") or string.find(fineparola,"p9") or string.find(fineparola,"r9") or string.find(fineparola,"s9") or string.find(fineparola,"t9") or string.find(fineparola,"x9") or string.find(fineparola,"9x") or string.find(fineparola,"v9") or string.find(fineparola,"z9") ~= nil then
			piana = true
		--cerca una vocale lunga a fine sillaba
		elseif string.find(fineparola,"ā9") or string.find(fineparola,"ē9") or string.find(fineparola,"ī9") or string.find(fineparola,"ō9") or string.find(fineparola,"ū9") or string.find(fineparola,"ȳ9") ~= nil then
			piana = true
		elseif string.find(fineparola,"ae9") or string.find(fineparola,"oe9") ~= nil then
			piana = true
		else
			piana = false
		end
	--adesso che sappiamo se la parola è sdrucciola o meno, si passa ad inserire l'accento 
		if piana == true then
			n = tonumber(nsill -2)
			pron = (string.gsub(pron,"9",".",n)) --trasforma in "." tutti i "9" fino alla penultima sillaba: 9lau9dā9vis9sent -> .lau.daː9wis9sent
			pron = (string.gsub(pron,"9","ˈ",1)) --trasforma il primo "9" che trova, che a questo punto sarà quello della sillaba tonica, in "ˈ": .lau.daː9wis9sent -> .lau.daːˈwis9sent
		else
			n = tonumber(nsill -3)
			pron = (string.gsub(pron,"9",".",n)) --trasforma in "." tutti i "9" fino alla terzultima sillaba: 9lau9dā9vis9sent -> .lau9daː9wis9sent
			pron = (string.gsub(pron,"9","ˈ",1)) --trasforma il primo "9" che trova, che a questo punto sarà quello della sillaba tonica, in "ˈ": .lau9daː9wis9sent -> .lauˈdaː9wis9sent
		end
	end 
	
	--leva di mezzo l'eventuale punto a inizio parola
	pron = (string.gsub(pron,"^%.",""))
	--trasforma in "." tutti i "9" che possono essere rimasti
	pron = (string.gsub(pron,"9","."))
	
	return pron --grazie a tutti e arrivederci
	
	end
	
function p.proneccl(frame)
	--questa funzione gestisce la pronuncia ECCLESIASTICA; trasforma la parola che viene inserita nella pronuncia IPA: cē9dō -> ˈʧe.do
	radice = frame.args[1] --l'argomento passato dal template, ad es. cē9dō
	tipo = frame.args[2] or nil
	zio = frame.args["zio"] or nil
	--per prima cosa sostituisce, a scaglioni, tutte le lettere o gruppi di lettere che lo necessitano. il processo è a tappe, ogni tappa sostituisce qualcosa
	--la pronuncia ecclesiastica è piùà complicata di quella classica (somiglia all'italiano), per cui ci sono più sostituizioni rispetto a sopra
	--i 9 che separano le sillabe vanno tenuti fino alla fine, perché serviranno. 
	
	--trasforma in minuscole tutte le lettere della radice (per evitare problemi in caso di nomi propri)
	pron = mw.ustring.lower(radice)
	
	--risolve i dittonghi: coe9pi -> cɛ9pi; lae9tus -> lɛ9tus; lau9do -> lau̯9do
	pron = (string.gsub(pron,"ae","ɛ"))
	pron = (string.gsub(pron,"oe","ɛ"))
	pron = (string.gsub(pron,"au","au̯"))
	
	--risolve le sillabe brevi e lunghe: mā9tĕr -> ma9ter
	local voc={ 
	['ā']='a',['ă']='a',
	['ē']='e',['ĕ']='e',
	['ī']='i',['ĭ']='i',
	['ō']='o',['ŏ']='o',
	['ū']='u',['ŭ']='u',
	['ȳ']='y',
	};
	pron = (mw.ustring.gsub(pron, '.', voc))
	
	--risolve il gruppo "s9ci", "s9ce": coɲ9ɲos.ce9re -> coɲ9ɲoʃ9ʃe9re
	pron = (string.gsub(pron,"s9ci","ʃ9ʃi"))
	pron = (string.gsub(pron,"s9ce","ʃ9ʃe"))
	pron = (string.gsub(pron,"s9cɛ","ʃ9ʃɛ"))
	--risolve il gruppo "sci", "sce" (non diviso da sillaba): sci9o -> ʃi9o
	pron = (string.gsub(pron,"sci","ʃi"))
	pron = (string.gsub(pron,"sce","ʃe"))
	pron = (string.gsub(pron,"scɛ","ʃɛ"))
	
	--risolve le "c" dolci a cavallo di sillaba: ac9cep9to -> at9ʧep9to
	pron = (string.gsub(pron,"c9ci","t9ʧi"))
	pron = (string.gsub(pron,"c9ce","t9ʧe"))
	pron = (string.gsub(pron,"c9cɛ","t9ʧɛ"))
	
	--risolve le "c" dolci: di9ci -> di9ʧi
	pron = (string.gsub(pron,"ci","ʧi"))
	pron = (string.gsub(pron,"ce","ʧe"))
	pron = (string.gsub(pron,"cɛ","ʧɛ"))
	
	--risolve le "g" dolci: ge9ro -> ʤe9ro
	pron = (string.gsub(pron,"gi","ʤi"))
	pron = (string.gsub(pron,"ge","ʤe"))
	pron = (string.gsub(pron,"gɛ","ʤɛ"))
	
	--risolve il gruppo "g9n": cog9nos9co -> coɲ9ɲos.9co
	pron = (string.gsub(pron,"g9n","ɲ9ɲ"))
	
	--risolve il gruppo "gn" (non diviso da sillaba): gnos9co -> ɲos9co
	pron = (string.gsub(pron,"gn","ɲ"))
	
	-- "gli" e "gle" dovrebbero mantenere la "g" dura in ogni caso; ad es. in negligo -> ˈne.ɡli.ɡo
	
	--risolve i gruppi "ti9a", "ti9e", ti9o", "ti9u": spa9ti9um -> spa9ʦi9um
	pron = (string.gsub(pron,"ti9a","ʦi9a"))
	pron = (string.gsub(pron,"ti9e","ʦi9e"))
	pron = (string.gsub(pron,"ti9o","ʦi9o"))
	pron = (string.gsub(pron,"ti9u","ʦi9u"))
	
	--fix per s + ti, che non fa "szi"
	pron = (string.gsub(pron,"s9ʦ","s9t"))
	
	if zio == "no" then
		pron = (string.gsub(pron,"ʦ","t"))
	end
	
	--risolve il gruppo "9x": vi9xi -> vik9si
	local ics={ 
	["9x"] = 'k9s'
	};
	pron = (string.gsub(pron,"%d%a",ics))
	
	--risolve i dittonghi in i-: iu9bi9lo -> ju9bi9lo
	local jay={ 
	["iu"] = 'ju', ["ia"] = 'ja', ["ie"] = 'je', ["io"] = 'jo', ["iɛ"] = 'jɛ'
	};
	pron = (string.gsub(pron,"%a%a",jay))
	--risolve i dittonghi in i- (che sono ora diventati in j-) a cavallo di sillaba: ba9ju9lus -> baj9ju9lus
local jays={ 
	["9ju"] = 'j9ju', ["9ja"] = 'j9ja', ["9je"] = 'j9je', ["9jo"] = 'j9jo', ["9jɛ"] = 'j9jɛ'
	};
	pron = (string.gsub(pron,"%d%a%a",jays))
	--risolve il gruppo "qu-": qua9si -> kʷa9si
local qua={ 
	["qu"] = 'kw'
	};
	pron = (string.gsub(pron,"%a%a",qua))
	
	--risolve varie consonanti: că9dō -> ka9do; lux -> luks eccetera
local cons={ 
	["c"] = 'k', --a questo punto le "c" (e le "g") rimaste dovrebbero essere tutte dure, visto che quelle dolci sono già state sostituite
	["x"] = 'ks',
	['h'] = ''
	};
	pron = (mw.ustring.gsub(pron, '.', cons))

--FINITE LE SOSTITUZIONI, bisogna iniziare a ragionare sull'accento, ovvero far venir fuori da mā9tĕr -> ˈma9ter e da a9dae9quō -> aˈdɛ̯.kwo
	--per prima cosa bisogna sapere di quante sillabe è composta la parola; per fortuna le sillabe sono separate da "9"
	pron = "9".. pron --aggiunge un "9" a inizio parola, per indicare la prima sillaba: mā9tĕr -> 9ma9ter
	nove = (string.gsub(pron,"%D","")) --elimina tutto tranne i numeri: 9ma9ter -> 99; 9ju9bi9lo -> 999; 9lau9da9vis9sent -> 9999
	nsill = tonumber(string.len(nove)) --conta quanto è lunga la stringa così creata; è in byte, ma per le cifre 1 cifra = 1 byte (spero): 9 -> 1; 99 -> 2; 999 -> 3; 9ma9ter -> 2

	--adesso che abbiamo il numero di sillabe, si vede dove casca l'accento
	--se la parola ha 1 o 2 sillabe, l'accento casca per forza sulla prima (almeno in questo il latino è comodo)
	if nsill < 3 then
		pron = (string.gsub(pron,"9","ˈ",1))
		
	--se invece la parola ha più di tre sillabe, bisogna invece andare a vedere se è piana (accento sull'ultima sillaba) o sdrucciola (accento sulla penultima sillaba); in latino non esistono né bisdrucciole né tronche
	--la discriminante è la penultima sillaba; in latino una parola è piana se questa:
		--a) termina per consonante, a prescindere dalla quantità della vocale: lau.dàn.tes
		--b) contiene una vocale lunga:  ha.bē.re -> ha.bè.re; di.cĕ.re -> dì.ce.re oppure un dittongo: a.dae.quo -> a.dàe.quo
			--c'è un'altra regola che dice che la parola è piana se termina con una enclitica (-cum, -que etc.), tipo "fratrèmque", ma non ci interessa ai fini di questo modulo
	else		
	--si va quindi a vedere che succede nella penultima sillaba
	-- NB: in tutta questa sezione si usa la stringa "radice", cioé la parola così come viene passata dal template, senza le sostituzioni fatte alla stringa "pron"; quindi le ā sono ancora ā, le ĕ ancora ĕ eccetera
		nsost = tonumber(nsill-2) --il numero di sillabe della parola meno due, ovvero meno l'ultima e la penultima
		fineparola = (string.gsub(radice,".-9","",nsost)) --elimina tutte le sillabe tranne le ultime due: lau9da9vis9sent = vis9sent
		
		--cerca una consonante a fine sillaba
		if string.find(fineparola,"b9") or string.find(fineparola,"c9") or string.find(fineparola,"d9") or string.find(fineparola,"f9") or string.find(fineparola,"g9") or string.find(fineparola,"k9") or string.find(fineparola,"l9") or string.find(fineparola,"m9") or string.find(fineparola,"n9") or string.find(fineparola,"p9") or string.find(fineparola,"r9") or string.find(fineparola,"s9") or string.find(fineparola,"t9") or string.find(fineparola,"x9") or string.find(fineparola,"9x") or string.find(fineparola,"v9") or string.find(fineparola,"z9") ~= nil then
			piana = true
		--cerca una vocale lunga a fine sillaba
		elseif string.find(fineparola,"ā9") or string.find(fineparola,"ē9") or string.find(fineparola,"ī9") or string.find(fineparola,"ō9") or string.find(fineparola,"ū9") or string.find(fineparola,"ȳ9") ~= nil then
			piana = true
		elseif string.find(fineparola,"ae9") or string.find(fineparola,"oe9") ~= nil then
			piana = true
		else
			piana = false
		end
	--adesso che sappiamo se la parola è sdrucciola o meno, si passa ad inserire l'accento 
		if piana == true then
			n = tonumber(nsill -2)
			pron = (string.gsub(pron,"9",".",n)) --trasforma in "." tutti i "9" fino alla penultima sillaba: 9lau9dā9vis9sent -> .lau.daː9wis9sent
			pron = (string.gsub(pron,"9","ˈ",1)) --trasforma il primo "9" che trova, che a questo punto sarà quello della sillaba tonica, in "ˈ": .lau.daː9wis9sent -> .lau.daːˈwis9sent
		else
			n = tonumber(nsill -3)
			pron = (string.gsub(pron,"9",".",n)) --trasforma in "." tutti i "9" fino alla terzultima sillaba: 9lau9dā9vis9sent -> .lau9daː9wis9sent
			pron = (string.gsub(pron,"9","ˈ",1)) --trasforma il primo "9" che trova, che a questo punto sarà quello della sillaba tonica, in "ˈ": .lau9daː9wis9sent -> .lauˈdaː9wis9sent
		end
	end 
	
	--leva di mezzo l'eventuale punto a inizio parola
	pron = (string.gsub(pron,"^%.",""))
	--trasforma in "." tutti i "9" che possono essere rimasti
	pron = (string.gsub(pron,"9","."))
	
	return pron --grazie a tutti e arrivederci
	end
	
return p