Modulo:Fr-conj/man

Questo modulo costituisce il codice di funzionamento del Template:Fr-conj e crea, in base ai parametri inseriti in quest'ultimo, la tabella di coniugazione dei verbi francesi. Si compone di una funzione principale, p.frconj (richiamata direttamente nel template) e di tre funzioni accessorie (p.over, p.wiki, e p.alts) 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.

Questo modulo è stato creato nel giugno 2014 a partire dal modulo:It-conj, a sua volta derivato dal corrispondente modulo di en.wikt, la cui cronologia riporta i relativi autori (NB: successive modifiche apportate tanto su en. quanto su it. hanno reso i due moduli molto diversi fra loro, per cui i relativi template potrebbero comportarsi in modo molto differente).

Funzione p.frconj

È la funzione principale del modulo; interpreta i parametri inseriti nel template (radice, desinenza all'infinito, ausiliare, eventuali forme irregolari) e in base ad essi costruisce la tabella che ne costituisce l'output. La funzione internamente è suddivisibile in sottosezioni identificate nel modulo dai -- commenti; tali sottosezioni vengono di seguito brevemente descritte separatamente.

La prima sottosezione definisce le variabili passate al modulo dal template:

• stem : la radice del verbo (ad. es. parl per "parler"); corrisponde al primo parametro del Template:Fr-conj
• type : la desinenza (all'infinito) del verbo (er, ir, er-se etc.); corrisponde al secondo parametro del Template:Fr-conj
• aus : l'ausiliare (être o avoir); corrisponde al terzo parametro del Template:Fr-conj

Successivamente vengono definite le variabili interne al template, che saranno poi codificate successivamente: ad es. inf per la voce verbale all'infinito, pres1s per la prima persona singolare del presente indicativo, prem1s per la prima persona singolare del passato remoto e così via; se si aggiunge una nuova variabile è bene aggiungerla anche a tale lista, altrimenti potrebbe risultare nulla.

Segue poi la costruzione delle voci verbali standard: in base alla desinenza (type) il modulo genera le stringhe per le varie forme flesse unendo radice (stem) e relativa uscita: ad es. se la desinenza è "er" (if type = "are"), pres1s = stem.. "e" (parle); prem1s = stem.. "ai" (parlai) e così via. Stesso discorso per i verbi riflessivi (tipe = "er-se" e simili).

Nella sottosezione identificata da -- Recupera le eventuali forme irregolari o varianti.., le stringhe per le voci verbali così create vengono riunite in stringhe uniche: la funzione p.over sostituisce la forma flessa generata automaticamente con quella eventualmente inserita manualmente nel template, se presente; la funzione p.alts aggiunge alla forma flessa generata automaticamente quella eventualmente inserita manualmente, se presente. Ad es. per il presente indicativo:

• pres1s = p.over(pres1s,args["pres1s"]) -> se nel template è inserito il parametro "pres1s=", viene sovrascritto a quello generato automaticamente
• pres1s = p.alts(pres1s, pres1s2) -> se nel template è inserito il parametro "pres1s2=", viene aggiunto accanto a quello generato automaticamente

Nella sottosezione -- Tempi composti vengono generate le forme per i tempi composti (passato prossimo etc.) e i relativi titoli dei cassetti. Prima si genera automaticamente, tramite la funzione p.plurale (vedi sotto), il plurale del participio passato pplur (necessario se l'ausiliare è essere). Successivamente, in base all'ausiliare inserito, si generano le stringhe per le varie voci verbali unendo ausiliare (coniugato) e participio passato: ad es. per il passato prossimo:

• se l'ausiliare è avoir (if aus = "avoir"), paspros1s = "[[ai]] ".. pp (ai parlé) e così via
• se l'ausiliare è être (if aus = "être"), paspros1s = "[[suis]] ".. pp e così via
• se il participio passato non esiste (if pp = "") le forme composte si annullano paspros1s = ""
• se l'ausiliare è diverso da "être" o "avoir" (else), escono le doppie forme composte paspros1s = "[[ai]] ".. pp, "[[suis]] ".. pp e così via.

Subito dopo si generano i titoli dei cassetti, con la corrispondente descrizione (se if pp = "", la descrizione è per tutti "manca dei tempi composti").

Infine, nella sottosezione -- Costruisce la tabella di coniugazione il modulo costruisce la tabella (conj) e vi inserisce le forme flesse precedentemente generate. Il modulo restituisce tale tabella con output (return conj).

Funzione p.over

La funzione p.over (p.over(x,over,xtra)) serve per sovrascrivere l'eventuale voce verbale irregolare (identificata dal suo secondo argomento, over), se definita, a quella generata automaticamente (identificata dal primo argomento x). Ad esempio, all'interno della funzione principale il codice

• pp = p.over(pp,args["pp"])

cerca l'eventuale parametro "pp=" (participio passato) nel template; se questo è definito lo rimpiazza alla forma predefinita, se non lo è restituisce invece quest'ultima.

Il terzo parametro xtra va settato su 0 solo nel caso dei verbi riflessivi, e inserisce la corrispondete particella pronominale ("me", "te" etc.), in tutti gli altri casi può essere ignorato.

Funzione p.wiki

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

Inoltre, la funzione controlla, tramite la funzione standard di Scribunto mw.title.new(x).exists (si veda anche qui) se la pagina a cui punta tale link esiste o meno (funziona in modo molto simile alla funzione parser ifexist del codice mediawiki). Se la pagina non esiste, aggiunge al wikilink la Categoria:Verbi francesi con forme da scrivere, e/o la Categoria:Verbi francesi da scrivere se ad essere rosso è il link verso la forma all'infinito.

Funzione p.alts

La funzione p.alts (p.alts(x, y)) aggiunge l'eventuale variante alternativa (identificata dal suo secondo argomento, y), se definita, accanto a quella generata automaticamente (identificata dal primo argomento x), separandola con una virgola. Ad esempio, all'interno della funzione principale, il codice

• pp = p.alts(pp, pp2)

cerca l'eventuale parametro "pp2=" (variante del participio passato) nel template; se questo è definito lo aggiunge al seguito di quella base, se non lo è restituisce invece solo quest'ultima.