po4a 0.20 - en to it translation catalogue (1056 entries)

note: type: Attribute 'xml:lang' of: <refentry>
en: en
it: it

note: type: Content of: <refentry><refmeta><refmiscinfo>
en: Po4a Tools
it: Strumenti Po4a

note: type: Content of: <refentry><refnamediv><refpurpose>
en: display a translated man page according to a PO
it: mostra una pagina man tradotta secondo un file PO

note: type: =head1
en: DESCRIPTION
it: DESCRIZIONE

note: type: Content of: <refentry><refsect1><para>
en: Translators can use <command>po4a-display-man</command> to see how their translation of a man page will be rendered to the end users, without recompiling and reinstalling the whole project.
it: I traduttori possono usare <command>po4a-display-man</command> per vedere come le loro traduzioni di una pagina man verranno rese agli utenti finali, senza dover ricompilare e reinstallare l'intero progetto.

note: type: Content of: <refentry><refsect1><para>
en: This script only works with man pages written directly in <emphasis remap='I'>nroff</emphasis> and handled by the po4a's <emphasis remap='I'>man</emphasis> module.  Manual pages generated from other formats, like DocBook or POD, are not supported.  See <citerefentry><refentrytitle>po4a-display-pod</refentrytitle><manvolnum>1</manvolnum></citerefentry> for an equivalent supporting <emphasis remap='I'>POD</emphasis> documents.
it: Questo script funziona solo con pagine man scritte direttamente in <emphasis remap='I'>nroff</emphasis> e gestite dal modulo <emphasis remap='I'>man</emphasis> di po4a.  Le pagine man generate da altri formati, come DocBook o POD, non sono supportate.  Consultare <citerefentry><refentrytitle>po4a-display-pod</refentrytitle><manvolnum>1</manvolnum></citerefentry> per un supporto equivalente ai documenti <emphasis remap='I'>POD</emphasis>.

note: type: =head1
en: OPTIONS
it: OPZIONI

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>
en: The PO file containing the translations.
it: Il file PO contenente le traduzioni.

note: .br type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>
en: The original man page.  It can be the absolute or relative path to the original man page (gzipped or not), the name of the man page or the name and section of the man page (using the man.section format).  When the master document is not provided with the <option>-m</option> option, <command>po4a-display-man</command> tries to find the original man page based on the line reference of the first string in the PO.
it: La pagina man originale.  Può essere un percorso assoluto o relativo alla pagina man originale (gzippata o no), il nome della pagina man o il nome e sezione della pagina man (usando il formato man.sezione).  Quando il documento master non viene fornito con l'opzione <option>-m</option>, <command>po4aman-display-man</command> prova a trovare la pagina mano originale basandosi sul riferimento di riga della prima stringa nel file PO.

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>
en: Some options to pass to <citerefentry><refentrytitle>po4a-translate</refentrytitle><manvolnum>1</manvolnum></citerefentry>.
it: Alcune opzioni da passare a <citerefentry><refentrytitle>po4a-translate</refentrytitle><manvolnum>1</manvolnum></citerefentry>.

note: type: =head1
en: SEE ALSO
it: VEDERE ANCHE

note: type: Content of: <refentry><refsect1><title>
en: AUTHOR
it: AUTORE

note: type: Content of: <refentry><refnamediv><refpurpose>
en: display of a translated POD file according to a PO
it: vista di un file POD tradotto secondo un PO

note: type: Content of: <refentry><refsynopsisdiv><cmdsynopsis>
en: <command>po4a-display-pod</command> <arg choice='plain'><option>-p </option></arg> <arg choice='plain'><replaceable>PO_FILE</replaceable></arg> <arg choice='plain'><option>-m </option></arg> <arg choice='plain'><replaceable>POD_FILE</replaceable></arg> <arg choice='opt'><arg choice='plain'><option>-o </option></arg><arg choice='plain'><replaceable>PO4A_OPT</replaceable></arg></arg>
it: <command>po4apod-display-pod</command> <arg choice='plain'><option>-p </option></arg> <arg choice='plain'><replaceable>PO_FILE</replaceable></arg> <arg choice='plain'><option>-m </option></arg> <arg choice='plain'><replaceable>POD_FILE</replaceable></arg> <arg choice='opt'><arg choice='plain'><option>-o </option></arg><arg choice='plain'><replaceable>PO4A_OPT</replaceable></arg></arg>

note: type: Content of: <refentry><refsect1><para>
en: Translators can use <command>po4a-display-pod</command> to see how their translation of a man page will be rendered to the end users, without recompiling and reinstalling the whole project.  Most of the time, the POD file is only available in source package or embedded in Perl script.
it: <command>po4apod-display-pod</command> può essere usato da un traduttore che vuole controllare come la pagina man, generata da un file POD, tradotta tramite un PO, verrà mostrata. Generalmente, il file POD è disponibile solo in un pacchetto sorgente o incorporato in uno script Perl.

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>
en: The original POD file used by po4a to generate PO file.
it: Il file POD originale usato da po4a per generare il file PO.

note: type: =head1
en: NAME
it: NOME

note: type: textblock
en: po4a - update both the PO files and translated documents in one shot
it: po4a - aggiorna i file PO e i documenti tradotti in un colpo solo

note: type: =head1
en: SYNOPSIS
it: SINTASSI

note: type: textblock
en: B<po4a> [I<options>] I<config_file>
it: B<po4a> [I<opzioni>] I<file_config>

note: type: textblock
en: po4a (PO for anything) eases the maintenance of documentation translation using the classical gettext tools. The main feature of po4a is that it decouples the translation of content from its document structure.  Please refer to the page L<po4a(7)> for a gentle introduction to this project.
it: po4a (PO for anything - N.d.T. PO per tutto) semplifica la manutenzione delle traduzioni della documentazione usando i classici strumenti forniti da gettext. La caratteristica principale di po4a è che separa la traduzione dei contenuti dalla struttura del relativo documento.  Fare riferimento alla pagina L<po4a(7)> per un'introduzione a questo progetto.

note: type: textblock
en: Upon execution, B<po4a> parses all documentation files specified in its configuration file. It updates the PO files (containing the translation) to reflect any change to the documentation, and produce a translated documentation by injecting the content's translation (found in the PO files) into the structure of the original master document.
it: Al momento dell'esecuzione, B<po4a> analizza tutti i file di documentazione specificati nel file di configurazione. Aggiorna i file PO (contenenti la traduzione) per riflettere eventuali modifiche alla documentazione e produce una documentazione tradotta inserendo la traduzione del contenuto (che si trova nei file PO) nella struttura del documento master originale.

note: type: textblock
en: At first, the PO files only contain the strings to translate from the original documentation. This file format allows the translators to manually provide a translation for each paragraph extracted by B<po4a>. If the documentation is modified after translation, B<po4a> marks the corresponding translations as "fuzzy" in the PO file to request a manual review by the translators. The translators can also provide so-called "addendum", that are extra content stating for example who did the translation and how to report bugs.
it: Inizialmente, i file PO contengono solo le stringhe da tradurre dalla documentazione originale. Questo formato di file consente ai traduttori di fornire manualmente una traduzione per ogni paragrafo estratto da B<po4a>. Se la documentazione viene modificata dopo la traduzione, B<po4a> contrassegna le traduzioni corrispondenti come "fuzzy" nel file PO per richiedere una revisione manuale da parte dei traduttori. I traduttori possono anche fornire i cosiddetti "addendum", che sono contenuti extra che indicano ad esempio chi ha eseguito la traduzione e come segnalare i difetti.

note: type: verbatim
en:  master documents ---+---->-------->---------+
      (doc authoring)    |                       |
                         V   (po4a executions)   >-----+--> translated
                         |                       |     |     documents
     existing PO files -->--> updated PO files >-+     |
          ^                            |               |
          |                            V               |
          +----------<---------<-------+               ^
           (manual translation process)                |
                                                       |
     addendum -->--------------------------------------+
it:  documenti master ---+----->---------->--------+
      (doc.ti orig.)     |                         |
                         V    (esecuzioni po4a)    >----+--> documenti
                         |                         |    |     tradotti
     file PO esistenti -->--> file PO aggiornati >-+    |
          ^                                |            |
          |                                V            |
          +------------<------------<------+            ^
           (processo di traduzione manuale)             |
                                                        |
     addendum -->---------------------------------------+

note: type: textblock
en: The workflow of B<po4a> is asynchronous, as suited to open-source projects. The documentation writers author the master documents at their own pace. The translators review and update the translations in the PO files. The maintainers rerun B<po4a> on need, to reflect any change to the original documentation to the PO files, and to produce updated documentation translations, by injecting the latest translation into the latest document structure.
it: Il flusso di lavoro di B<po4a> è asincrono, adatto ai progetti open source. Gli autori della documentazione creano i documenti master al proprio ritmo. I traduttori esaminano e aggiornano le traduzioni nei file PO. I manutentori rieseguono B<po4a> se necessario, per riflettere qualsiasi modifica alla documentazione originale nei file PO e per produrre traduzioni della documentazione aggiornate, inserendo l'ultima traduzione nella struttura del documento più recente.

note: type: textblock
en: By default, a given translated document is produced when at least 80% of its content is translated. The untranslated text is kept in the original language.  The produced documentation thus mixes languages if the translation is not complete. You can change the 80% threshold with the I<--keep> option described below. Note however that discarding translations as soon as they are not 100% may be discouraging for the translators whose work will almost never be shown to the users, while showing "translations" that are too incomplete may be troubling for the end users.
it: Per impostazione predefinita, un determinato documento tradotto viene prodotto quando viene tradotto almeno l'80% del suo contenuto. Il testo non tradotto è mantenuto nella lingua originale. La documentazione prodotta mescola quindi lingue se la traduzione non è completa. È possibile modificare la soglia dell'80% con l'opzione I<-- keep> descritta di seguito. Si noti tuttavia che scartare le traduzioni appena sotto al 100% può essere scoraggiante per i traduttori il cui lavoro non verrà quasi mai mostrato agli utenti, mentre mostrare "traduzioni" troppo incomplete può creare problemi per gli utenti finali.

note: type: textblock
en: Storing the translated documentation files in the version control system is probably a bad idea, since they are automatically generated. The precious files are the PO files, that contain the hard work of your fellow translators. Also, some people find it easier to interact with the translators through an online platform such as S<weblate>, but this is naturally fully optional.
it: La memorizzazione dei file di documentazione tradotti nel sistema di controllo versionamento è probabilmente una cattiva idea, poiché vengono generati automaticamente. I file importanti sono i file PO, che contengono il duro lavoro dei colleghi traduttori. Inoltre, alcune persone trovano più facile interagire con i traduttori attraverso una piattaforma online come S<weblate>, ma questo è naturalmente opzionale.

note: type: =head2
en: Quick start tutorial
it: Guida di avvio rapido

note: type: textblock
en: Let's assume you maintain a program named B<foo> which has a man page F<man/foo.1> written in English (the bridge language in most open-source projects, but B<po4a> can be used from or to any language). Some times ago, someone provided a German translation named F<man/foo.de.1> and disappeared.  This is a problem because you just got a bug report saying that your documentation contains a gravely misleading information that must be fixed in all languages, but you don't speak German so you can only modify the original, not the translation. Now, another contributor wants to contribute a translation to Japanese, a language that you don't master either.
it: Supponiamo di mantenere un programma chiamato B<foo> che ha una pagina man F<man/foo.1> scritta in inglese (il linguaggio ponte nella maggior parte dei progetti open-source, ma B<po4a> può essere usato da o verso qualsiasi linguaggio). Qualche tempo fa, qualcuno ha fornito una traduzione manuale in tedesco chiamata F<man/foo.de.1> ed è scomparso. Questo è un problema perché hai appena ricevuto una segnalazione di bug che dice che la tua documentazione contiene informazioni gravemente fuorvianti che devono essere corrette in tutte le lingue, ma non parli tedesco quindi puoi solo modificare l'originale, non la traduzione. Ora, un altro collaboratore vuole contribuire con una traduzione in giapponese, un'altra lingua che non si mastica.

note: type: textblock
en: It is time to convert your documentation to B<po4a> to solve your documentation maintenance nightmares. You want to update the doc when needed, you want to ease the work of your fellow translators, and you want to ensure that your users never see any outdated and thus misleading documentation.
it: È ora di convertire la documentazione a B<po4a> per risolvere la manutenzione da incubo della documentazione. Si vuole aggiornare il documento quando serve, facilitare il lavoro dei colleghi traduttori e assicurare che gli utenti non vedano mai documentazioni obsolete e quindi fuorviante.

note: type: textblock
en: The conversion includes two steps: setup the po4a infrastructure, and convert the previous German translation to salvage the previous work. This latter part is done using S<po4a-gettextize>, as follows. As detailed in the documentation of L<po4a-gettextize(1)>, this process rarely fully automatic, but once it's done, the B<de.po> file containing the German translation can be integrated in your po4a workflow.
it: La conversione comprende due passaggi: configurare l'infrastruttura po4a e convertire la precedente traduzione tedesca per salvare il lavoro precedente. Quest'ultima parte viene eseguita utilizzando S<po4a-gettextize>, come segue. Come dettagliato nella documentazione di L<po4a-gettextize(1)>, questo processo raramente è anche completamente automatico, ma una volta terminato, il file B<de.po> contenente la traduzione tedesca può essere integrato nel flusso di lavoro di po4a.

note: type: textblock
en: Let's now configure po4a. With the appropriate file layout, your configuration file could be as simple as this:
it: Configuriamo ora po4a. Con la disposizione file appropriata, la configurazione potrebbe assomigliare ad un semplice file come questo:

note: type: textblock
en: It specifies that all PO files (containing the work of the translators) are the F<man/po4a/> directory, and that you have only one master file, F<man/foo.1>. If you had several master files, you would have several lines similar to the second one. Each such line also specify where to write the corresponding translation files. Here, the German translation of F<man/foo.1> is in F<man/translated/foo.de.1>.
it: Specifica che tutti i file PO (contenenti il lavoro dei traduttori) sono la cartella F<man/po4a/> e che si ha un solo file master, F<man/foo.1>. Se si avesse più file master, si avrebbero più righe simili alla seconda. Ciascuna di queste righe specifica anche dove scrivere i file di traduzione corrispondenti. Qui, la traduzione tedesca di F<man/foo.1> è in F<man/translated/foo.de.1>.

note: type: textblock
en: The last thing we need to complete the configuration of B<po4a> is a POT file containing the template material that should be used to start a new translation.  Simply create an empty file with the S<.pot> extension in the specified S<po_directory> (e.g. F<man/po4a/foo.pot>), and B<po4a> will fill it with the expected content.
it: L'ultima cosa di cui abbiamo bisogno per completare la configurazione di B<po4a> è un file POT contenente il materiale del modello che dovrebbe essere usato per iniziare una nuova traduzione. Basta creare un file vuoto con l'estensione S<.pot> nella S<po_directory> specificata (ad es. F<man/po4a/foo.pot>) e B<po4a> lo riempirà con il contenuto previsto.

note: type: textblock
en: Here is a recap of the files in this setup:
it: Ecco un riassunto dei file in questa impostazione:

note: type: verbatim
en:   ├── man/
      │   ├── foo.1        <- The original man page, in English.
      │   ├── po4a/
      │   │   ├── de.po    <- The German PO translation, from gettextization.
      │   │   └── foo.pot  <- The POT template of future translations (empty at first)
      │   └── translated/  <- Directory where the translations will be created
      └── po4a.cfg         <- The configuration file.
it:   ├── man/
      │   ├── foo.1        <- La pagina man originale, in inglese
      │   ├── po4a/
      │   │   ├── de.po    <- La traduzione PO in tedesco, dalla gettext-izzazione
      │   │   └── foo.pot  <- Il modello POT per future traduzioni (all'inizio vuoto)
      │   └── translated/  <- La cartella dove verranno create le traduzioni
      └── po4a.cfg         <- Il file di configurazione

note: type: textblock
en: Once setup, executing B<po4a> will parse your documentation, update the POT template file, use it to update the PO translation files, and use them to update the documentation translation files. All in one command:
it: Una volta impostato, l'esecuzione di B<po4a> analizzerà la documentazione, aggiornerà il file modello POT, lo utilizzerà per aggiornare i file di traduzione PO e li utilizzerà per aggiornare i file di traduzione della documentazione. Tutto in un comando:

note: type: textblock
en: This it. B<po4a> is now fully configured. Once you've fixed your error in F<man/foo.1>, the offending paragraph in the German translation will be replaced by the fixed text in English. Mixing languages is not optimal, but it's the only way to remove errors in translations that you don't even understand, and ensure that the content presented to the users is never misleading. Updating the German translation is also much easier in the corresponding PO file, so the language mix-up may not last long. Finally, when the Japanese translator gives you a S<jp.po> translated file, just drop it in F<man/po4a/po/>. A translated page will appear as F<man/translated/foo.jp.1> (provided that enough content is translated) when you run B<po4a> again.
it: Fatto. B<po4a> è ora completamente configurato. Dopo aver corretto l'errore in F<man/foo.1>, il paragrafo colpevole nella traduzione tedesca sarà sostituito dal testo corretto in inglese. Mescolare le lingue non è ottimale, ma è l'unico modo per rimuovere errori nelle traduzioni che non si comprendono (N.d.T. perché in altra lingua) e garantire che il contenuto presentato agli utenti non sia mai obsoleto. Anche l'aggiornamento della traduzione tedesca è molto più semplice nel file PO corrispondente, quindi il disguido linguistico potrebbe non durare a lungo. Infine, quando il traduttore giapponese fornirà un file tradotto S<jp.po>, basterà metterlo in F<man/po4a/po/>. Una pagina tradotta apparirà come F<man/translated/foo.jp.1> quando si eseguirà nuovamente B<po4a> (sempre che il contenuto tradotto sia sufficientemente completo).

note: type: textblock
en: Minimal threshold for translation percentage to keep (i.e. write) the resulting file (default: 80). I.e. by default, files have to be translated at least at 80% to be written on disk.
it: Minima percentuale di traduzione richiesta affinché il file generato sia mantenuto (cioè scritto) su disco. Il valore predefinito è 80, vale a dire che una traduzione viene scritta su disco solo se è completa almeno per l'80%.

note: type: textblock
en: Show a short help message.
it: Mostra un breve messaggio di aiuto.

note: type: textblock
en: Charset of the files containing the documents to translate. Note that all master documents must use the same charset.
it: Set di caratteri dei file contenenti i documenti da tradurre. Tutti i documenti master devono usare la stessa codifica.

note: type: textblock
en: Charset of the files containing the localized documents. Note that all translated documents will use the same charset.
it: Set di caratteri dei file contenenti i documenti localizzati. Tutti i documenti tradotti useranno la stessa codifica.

note: type: textblock
en: Charset of the addenda. Note that all the addenda should be in the same charset.
it: Set di caratteri degli addenda. Tutti gli addenda devono usare la stessa codifica.

note: type: textblock
en: Display the version of the script and exit.
it: Mostra la versione del programma ed esce.

note: type: textblock
en: Increase the verbosity of the program.
it: Rende il programma più prolisso.

note: type: textblock
en: Decrease the verbosity of the program.
it: Rende il programma meno prolisso.

note: type: textblock
en: Output some debugging information.
it: Mostra delle informazioni di debug

note: type: textblock
en: Extra option(s) to pass to the format plugin. See the documentation of each plugin for more information about the valid options and their meanings. For example, you could pass '-o tablecells' to the AsciiDoc parser, while the text parser would accept '-o tabs=split'.
it: Opzioni extra da passare al plugin di formato. Vedere la documentazione per ogni plugin per ulteriori informazioni sulle opzioni valide e sul loro significato. Per esempio si può passare "-o tablecells" al parser AsciiDoc mentre il parser di testo semplice accetta "-o tabs=split".

note: type: textblock
en: Always generate the POT and PO files, even if B<po4a> considers it is not necessary.
it: Genera sempre i file POT e PO, anche se B<po4a> non lo considera necessario.

note: type: textblock
en: The default behavior (when B<--force> is not specified) is the following:
it: Il comportamento predefinito (quando non è specificato B<--force>) è il seguente:

note: type: textblock
en: If the POT file already exists, it is regenerated if a master document or the configuration file is more recent (unless B<--no-update> is provided).  The POT file is also written in a temporary document and B<po4a> verifies that the changes are really needed.
it: Se il file POT esiste già, viene rigenerato se un documento master o il file di configurazione sono più recenti (a meno che non venga fornito B<--no-update>).  Il file POT viene scritto anche in un documento temporaneo e B<po4a> verifica che i cambiamenti siano veramente necessari.

note: type: textblock
en: Also, a translation is regenerated only if its master document, the PO file, one of its addenda or the configuration file is more recent.  To avoid trying to regenerate translations which do not pass the threshold test (see B<--keep>), a file with the F<.po4a-stamp> extension can be created (see B<--stamp>).
it: Inoltre, una traduzione viene rigenerata solo se il suo documento master, il file PO, uno dei suoi addendum o il file di configurazione sono più recenti.  Per evitare di provare a rigenerare le traduzioni che non passano il test di soglia (vedere B<--keep>), un file con estensione F<.po4a-stamp> può venir creato (vedere B<--stamp>).

note: type: textblock
en: If a master document includes files, you should use the B<--force> flag because the modification time of these included files are not taken into account.
it: Se un documento master include dei file, si dovrebbe usare la flag B<--force> perché il tempo di modifica di questi file inclusi non sono tenuti in considerazione.

note: type: textblock
en: The PO files are always re-generated based on the POT with B<msgmerge -U>.
it: I file PO vengono sempre rigenerati in base al POT con B<msgmerge -U>.

note: type: textblock
en: Tells B<po4a> to create stamp files when a translation is not generated because it does not reach the threshold. These stamp files are named according to the expected translated document, with the F<.po4a-stamp> extension.
it: Dice a B<po4a> di creare dei file stamp quando una traduzione non viene generata perché essa non raggiunge la soglia. A questi file stamp viene assegnato un nome in accordo con il nome previsto del documento tradotto, ed applicata estensione F<.po4a-stamp>.

note: type: textblock
en: Note: This only activates the creation of the F<.po4a-stamp> files. The stamp files are always used if they exist, and they are removed with B<--rm-translations> or when the file is finally translated.
it: Nota: ciò attiva solo la creazione dei file F<.po4a-stamp>. I file stamp vengono sempre usati se esistono, e vengono rimossi con l'uso di B<--rm-translations> o quando il file viene infine tradotto.

note: type: textblock
en: Do not generate the translated documents, only update the POT and PO files.
it: Non generare i documenti tradotti, aggiorna solo i file POT e PO.

note: type: textblock
en: Do not change the POT and PO files, only the translation may be updated.
it: Non cambiare i file POT e PO, solo la traduzione può essere aggiornata.

note: type: textblock
en: Keeps the existing translation files even if the translation doesn't meet the threshold specified by B<--keep>.  This option does not create new translation files with few content, but it will save existing translations which decay because of changes to the master files.
it: Mantiene i file di traduzione esistenti anche se la traduzione non incontra la soglia specificata da --keep.  Questa opzione non crea nuovi file di traduzione con poco contenuto, ma salverà le traduzioni esistenti che scadranno a causa dei cambiamenti ai file master.

note: type: textblock
en: WARNING: This flag changes the po4a behavior in a rather drastic way: your translated files will not get updated at all until the translation improves. Only use this flag if you prefer shipping an outdated translated documentation rather than only shipping an accurate untranslated documentation.
it: ATTENZIONE: questo flag cambia il comportamento di po4a in modo piuttosto radicale: i file tradotti non verranno aggiornati per nulla fino a quando la traduzione non migliorerà. Usare questo flag se si preferisce inviare una documentazione tradotta non aggiornata piuttosto che spedire solo una documentazione accurata non tradotta.

note: type: textblock
en: Remove the translated files (implies B<--no-translations>).
it: Rimuovi i file tradotti (implica B<--no-translations>).

note: type: textblock
en: This flag does nothing since 0.41, and may be removed in later releases.
it: Questo flag non fa nulla dalla versione 0.41, e potrebbe venir rimosso dalle prossime versioni.

note: type: =item
en: B<--translate-only> I<translated-file>
it: B<--translate-only> I<file-tradotto>

note: type: textblock
en: Translate only the specified file.  It may be useful to speed up processing if a configuration file contains a lot of files.  Note that this option does not update PO and POT files.  This option can be used multiple times.
it: Traduce solo il file specificato.  Può essere utile per velocizzare il processo se un file di configurazione contiene molti file. Si noti che questa opzione non aggiorna i file PO e POT.  Questa opzione può essere usata più volte.

note: type: =item
en: B<--variable> I<var>B<=>I<value>
it: B<--variable> I<var>B<=>I<valore>

note: type: textblock
en: Define a variable that will be expanded in the B<po4a> configuration file.  Every occurrence of I<$(var)> will be replaced by I<value>.  This option can be used multiple times.
it: Definisce una variabile che verrà espansa nel file di configurazione B<po4a>.  Ogni occorrenza di I<$(var)> verrà rimpiazzata da I<value>.  Questa opzione può essere usata più volte.

note: type: textblock
en: Set the base directory for all input documents specified in the B<po4a> configuration file.
it: Imposta la cartella di base per tutti i documenti in ingresso specificati nel file di configurazione B<po4a>.

note: type: textblock
en: If both I<destdir> and I<srcdir> are specified, input files are searched in the following directories, in order: I<destdir>, the current directory and I<srcdir>. Output files are written to I<destdir> if specified, or to the current directory.
it: Se vengono specificati sia I<destdir> che I<srcdir>, i file in ingresso vengono cercati nelle seguenti cartelle, in ordine: I<destdir>, la cartella corrente e I<srcdir>. I file in uscita vengono scritti su I<destdir> se specificata, o nella cartella corrente.

note: type: textblock
en: Set the base directory for all the output documents specified in the B<po4a> configuration file (see B<--srcdir> above).
it: Imposta la cartella di base per tutti i documenti in uscita specificati nel file di configurazione (vedere B<--srcdir> sopra).

note: type: =head2
en: Options modifying the POT header
it: Ozioni che modificano l'intestazione POT

note: type: =item
en: B<--porefs> I<type>
it: B<--porefs> I<tipo>

note: type: textblock
en: Specify the reference format. Argument I<type> can be one of B<never> to not produce any reference, B<file> to only specify the file without the line number, B<counter> to replace line number by an increasing counter, and B<full> to include complete references (default: full).
it: Specifica il formato di riferimento. L'argomento I<type> può essere un valore qualsiasi tra: B<never> per non produrre nessun riferimento, B<file> per specificare solo il file senza il numero di riga, B<counter> per rimpiazzare il numero di riga con un contatore incrementale, e B<full> per includere il riferimento completo (valore predefinito: full).

note: type: =item
en: B<--wrap-po> B<no>|B<newlines>|I<number> (default: 76)
it: B<--wrap-po> B<no>|B<newlines>|I<numero> (predefinito: 76)

note: type: textblock
en: Specify how the po file should be wrapped. This gives the choice between either files that are nicely wrapped but could lead to git conflicts, or files that are easier to handle automatically, but harder to read for humans.
it: Specifica come il file po deve essere mandato a capo. Consente di scegliere tra file con righe mandate capo ben formattate e quindi ben leggibili ma che potrebbero portare a conflitti in git o file che sono più facili da gestire automaticamente, ma più difficili da leggere per le persone.

note: type: textblock
en: Historically, the gettext suite has reformatted the po files at the 77th column for cosmetics. This option specifies the behavior of po4a. If set to a numerical value, po4a will wrap the po file after this column and after newlines in the content. If set to B<newlines>, po4a will only split the msgid and msgstr after newlines in the content. If set to B<no>, po4a will not wrap the po file at all.  The reference comments are always wrapped by the gettext tools that we use internally.
it: Storicamente, la suite gettext riformattava i file po alla 77a colonna per questioni estetiche. Questa opzione specifica il comportamento di po4a. Se impostato su un valore numerico, po4a manderà a capo il file po a questo numero di colonna e dopo i caratteri di a capo nel testo. Se impostato su B<newlines>, po4a dividerà msgstr e msgstr solo dopo i caratteri di a capo nel testo. Se impostato su B<no>, po4a non metterà a capo nel testo del file po. L'andare a capo nei commenti di riferimento è controllato dagli strumenti gettext che vengono usati internamente.

note: type: textblock
en: Note that this option has no impact on how the msgid and msgstr are wrapped, i.e.  on how newlines are added to the content of these strings.
it: Si noti che questa opzione non ha alcun impatto sul modo in cui msgstr e msgstr vanno a capo, cioè su come i caratteri di a capo vengono aggiunti al contenuto di queste stringhe.

note: type: textblock
en: Language of the source files containing the documents to translate. Note that all master documents must use the same language.
it: La lingua dei file contenenti il documento da tradurre. Tutti i file devono usare la stessa lingua.

note: type: =item
en: B<--msgid-bugs-address> I<email@address>
it: B<--msgid-bugs-address> I<indirizzo@email>

note: type: textblock
en: Set the report address for msgid bugs. By default, the created POT files have no Report-Msgid-Bugs-To fields.
it: Imposta l'indirizzo a cui inviare i rapporti di errore per i msgid. Come impostazione predefinita, i file POT creati non hanno campi Report-Msgid-Bugs-To.

note: type: =item
en: B<--copyright-holder> I<string>
it: B<--copyright-holder> I<stringa>

note: type: textblock
en: Set the copyright holder in the POT header. The default value is "Free Software Foundation, Inc."
it: Imposta l'intestatario del copyright nell'intestazione del POT. Il valore predefinito è "Free Software Foundation, Inc."

note: type: =item
en: B<--package-name> I<string>
it: B<--package-name> I<stringa>

note: type: textblock
en: Set the package name for the POT header. The default is "PACKAGE".
it: Imposta il nome del pacchetto nell'intestazione del POT. Il valore predefinito è "PACKAGE".

note: type: =item
en: B<--package-version> I<string>
it: B<--package-version> I<stringa>

note: type: textblock
en: Set the package version for the POT header. The default is "VERSION".
it: Imposta la versione del pacchetto nell'intestazione del POT. Il valore predefinito è "VERSION".

note: type: =head2
en: Options to modify the PO files
it: Opzioni che modificano i file PO

note: type: =item
en: B<--msgmerge-opt> I<options>
it: B<--msgmerge-opt> I<opzioni>

note: type: textblock
en: Extra options for B<msgmerge>(1).
it: Opzioni extra per B<msgmerge>(1).

note: type: textblock
en: Note: B<$lang> will be extended to the current language.
it: Nota: B<$lang> verrà estesa alla lingua corrente.

note: type: textblock
en: This option removes B<--previous> from the options passed to B<msgmerge>.  This is necessary to support versions of B<gettext> earlier than 0.16.
it: Questa opzione rimuove B<--previous> dalle opzioni passate a B<msgmerge>.  Ciò è necessario per supportare versioni di B<gettext> precedenti alla 0.16.

note: type: textblock
en: This option adds B<--previous> to the options passed to B<msgmerge>.  It requires B<gettext> 0.16 or later, and is activated by default.
it: Questa opzione aggiunge B<--previous> alle opzioni passate a B<msgmerge>.  Richiede B<gettext> 0.16 o successive, ed è attivata come impostazione predefinita.

note: type: =head1
en: CONFIGURATION FILE
it: FILE DI CONFIGURAZIONE

note: type: textblock
en: po4a expects a configuration file as argument. This file must contain the following elements:
it: po4a si aspetta un file di configurazione come argomento. Questo file deve contenere i seguenti elementi:

note: type: textblock
en: The path to the PO files and the list of languages existing in the project;
it: Il percorso ai file PO e l'elenco delle lingue esistenti nel progetto;

note: type: textblock
en: Optionally, some global options and so-called configuration aliases that are used as templates to configure individual master files;
it: Opzionalmente, alcune opzioni globali e i cosidetti alias di configurazione che vengono usati come modelli per configurare i singoli file master;

note: type: textblock
en: The list of each master file to translate, along with specific parameters.
it: L'elenco dei singoli file master da tradurre, insieme a parametri specifici.

note: type: textblock
en: All lines contain a command between square braces, followed by its parameters.  Comments begin with the char '#' and run until the end of the line. You can escape the end of line to spread a command over several lines.
it: Tutte le righe contengono un comando tra parentesi quadre, seguito dai suoi parametri.  I commenti cominciano con il carattere '#' e continuano fino alla fine della riga. Si può fare escape del carattere di fine riga per distribuire un comando su più righe.

note: type: textblock
en: Some full examples are presented on this page, while other examples can be found in the C<t/cfg> directory of the source distribution.
it: Alcuni esempi completi sono presenti su questa pagina, mentre altri esempi si possono trovare nella cartella C<t/cfg> della distribuzione dei sorgenti.

note: type: =head2
en: Finding the PO and POT files
it: Trovare i file POT e PO

note: type: textblock
en: The simplest solution is to explicitly give the path to POT and PO files, as follows:
it: La soluzione più semplice è indicare il percorso ai file POT e PO nel modo seguente:

note: type: textblock
en: This specifies the path to the POT file first, and then the paths to the German and French PO files.
it: Questo specifica prima il percorso verso il file POT, e poi i percorsi ai file PO tedesco e francese.

note: type: textblock
en: The same information can be written as follows to reduce the risk of copy/paste errors:
it: La stessa informazione può essere scritta come di seguito per ridurre il rischio di errori di copia/incolla:

note: type: textblock
en: The C<$lang> component is automatically expanded using the provided languages list, reducing the risk of copy/paste error when a new language is added.
it: La componente C<$lang> viene automaticamente espansa usando l'elenco lingue fornito, riducendo il rischio di errori di copia/incolla quando una nuova lingua viene aggiunta.

note: type: textblock
en: You can further compact the same information by only providing the path to the directory containing your translation project, as follows.
it: Si possono compattare ulteriormente le stesse informazioni fornendo solamente il percorso per la cartella contenente il progetto di traduzione, come di seguito.

note: type: textblock
en: The provided directory must contain a set of PO files, each named F<XX.po> with C<XX> the ISO 639-1 of the language used in this file. The directory must also contain a single POT file, with the C<.pot> file extension. For the first run, this file can be empty but it must exist (po4a cannot guess the name to use before the extension).
it: La cartella fornita deve contenere un insieme di file PO, ognuno con nome F<XX.po> dove C<XX> è il codice ISO 639-1 della lingua usata in questo file. La cartella deve anche contenere un singolo file POT, con estensione file C<.pot> . Nella prima esecuzione, quest'ultimo può essere vuoto ma deve esistere (po4a non può indovinare il nome da usare davanti all'estensione).

note: type: textblock
en: Note that you must choose only one between C<po_directory> and C<po4a_paths>. The first one (C<po_directory>) is more compact, further reduces the risk of copy/paste error, but forces you to use the expected project structure and file names. The second one (C<po4a_paths>), is more explicit, probably more readable, and advised when you setup your first project with po4a.
it: Si noti che bisogna scegliere solo uno tra C<po_directory> e C<po4a_paths>. Il primo (C<po_directory>) è più compatto, inoltre riduce il rischio degli errori di copia/incolla, ma forza ad usare la struttura progetto e i nomi file previsti. Il secondo (C<po4a_paths>), è più esplicito, probabilmente più leggibile, e suggerito quando si imposta il primo progetto con po4a.

note: type: =head3
en: Centralized or split PO files?
it: File PO centralizzati o separati?

note: type: textblock
en: By default, po4a produces one single PO file per target language, containing the whole content of your translation project. As your project grows, the size of these files may become problematic. When using weblate, it is possible to specify priorities for each translation segment (i.e., msgid) so that the important ones get translated first. Still, some translation teams prefer to split the content in several files.
it: Per impostazione predefinita, po4a produce un singolo file PO per lingua obiettivo, con l'intero contenuto del progetto di traduzione. Come il progetto cresce, la dimensione di questi file può diventare problematica. Quando si usa weblate, è possibile specificare priorità per ogni segmento di traduzione (cioè msgid) in modo tale da far tradurre i più importanti per primi. Comunque, alcune squadre di traduzione preferiscono dividere il contenuto in più file.

note: type: textblock
en: To have one PO file per master file, you simply have to use the string C<$master> in the name of your PO files on the C<[po4a_paths]> line, as follows.
it: Per avere un file PO per file master, basta semplicemente usare la stringa C<$master> nel nome dei file PO nella riga C<[po4a_paths]>, come di seguito.

note: type: textblock
en: With this line, po4a will produce separate POT and PO files for each document to translate.  For example, if you have 3 documents and 5 languages, this will result in 3 POT files and 15 PO files. These files are named as specified on the C<po4a_paths> template, with C<$master> substituted to the basename of each document to translate. In case of name conflict, you can specify the POT file to use as follows, with the C<pot=> parameter.
it: Con questa riga, po4a produrrà file POT e PO separati per ogni documento da tradurre. Ad esempio, se si hanno 3 documenti e 5 lingue, ciò porterà ad avere 3 file POT e 15 file PO. Questi file saranno denominati come specificato nel modello C<po4a_paths>, con C<$master> sostituito con il nome di base di ciascun documento da tradurre. In caso di conflitto di nomi, è possibile specificare il file POT da utilizzare come segue, con il parametro C<pot=>.

note: type: textblock
en: This feature can also be used to group several translated files into the same POT file. The following example only produces 2 POT files: F<l10n/po/foo.pot> (containing the material from F<foo/gui.xml>) and F<l10n/po/bar.pot> (containing the material from both F<bar/gui.xml> and F<bar/cli.xml>).
it: Questa funzione può essere utilizzata anche per raggruppare più file tradotti nello stesso file POT. L'esempio seguente produce solo 2 file POT: F<l10n/po/foo.pot> (contenente il materiale di F<foo/gui.xml>) e F<l10n/po/bar.pot> (contenente il materiale di entrambi F<bar/gui.xml> e F<bar/cli.xml>).

note: type: textblock
en: In split mode, B<po4a> builds a temporary compendium during the PO update, to share the translations between all the PO files. If two PO files have different translations for the same string, B<po4a> will mark this string as fuzzy and will submit both translations in all the PO files containing this string. When unfuzzied by the translator, the translation is automatically used in every PO files.
it: In modalità split, B<po4a> crea un compendio temporaneo durante l'aggiornamento PO, per condividere le traduzioni tra tutti i file PO. Se due PO hanno traduzioni diverse per la stessa stringa, B<po4a> marcherà questa stringa come fuzzy e inserirà entrambe le traduzioni in tutti i file PO contenenti questa stringa. Poi, quando un traduttore aggiornerà la traduzione e rimuoverà la marcatura fuzzy in un file PO, la traduzione di questa stringa verrà aggiornata in ogni file PO automaticamente.

note: type: =head2
en: Specifying the documents to translate
it: Specificare i documenti da tradurre

note: type: textblock
en: You must also list the documents that should be translated. For each master file, you must specify the format parser to use, the location of the translated document to produce, and optionally some configuration. Here is an example:
it: Bisogna anche elencare i documenti che dovrebbero essere tradotti. Per ogni file master, bisogna specificare il processatore del formato da usare, la posizione del documento tradotto da produrre, e opzionalmente qualche configurazione. Ecco un esempio:

note: type: textblock
en: But again, these complex lines are difficult to read and modify, e.g. when adding a new language. It is much simpler to reorganize things using the C<$lang> template as follows:
it: Ma ancora, queste righe complesse sono difficili da leggere e da modificare, per es. quando si vuole aggiungere una lingua. È molto più semplice riorganizzare le cose usando il modello C<$lang> come di seguito:

note: type: =head2
en: Specifying options
it: Specificare le opzioni

note: type: textblock
en: There is two types of options: I<po4a options> are default values to the po4a command line options while I<format options> are used to change the behavior of the format parsers. As a I<po4a options>, you could for example specify in your configuration file that the default value of the B<--keep> command line parameter is 50% instead of 80%. I<Format options> are documented on the specific page of each parsing module, e.g. L<Locale::Po4a::Xml(3pm)>. You could for example pass B<nostrip> to the XML parser to not strip the spaces around the extracted strings.
it: Ci sono due tipi di opzioni: le I<opzioni po4a> sono valori predefiniti alle opzioni di riga di comando po4a mentre le I<opzioni di formato> vengono usate per cambiare il comportamento dei parser di formato. Con una I<opzione po4a>, si può per esempio specificare nel file di configurazione che il valore predefinito del parametro a riga di comando B<--keep> è 50% invece che 80%. Le I<opzioni di formato> sono documentate nella pagina specifica di ogni modulo di elaborazione, per es. L<Locale::Po4a::Xml(3pm)>. Si può per esempio passare B<nostrip> al parser XML per non eliminare gli spazi attorno alle stringhe estratte.

note: type: textblock
en: You can pass these options for a specific master file, or even for a specific translation of that file, using C<opt:> and C<opt_XX:> for the C<XX> language.  In the following example, the B<nostrip> option is passed to the XML parser (for all languages), while the threshold will be reduced to 0% for the French translation (that is thus always kept).
it: È possibile passare queste opzioni per un file master specifico, o persino per una specifica traduzione di quel file, usando C<opt:> e C<opt_XX:> per la lingua C<XX>.  Nell'esempio seguente, viene passata l'opzione B<nostrip> al parser XML (per tutte le lingue), mentre la soglia viene ridotta a 0% per la traduzione francese (che significa perciò che sarà sempre mantenuta).

note: type: textblock
en: In any case, these configuration chunks must be located at the end of the line.  The declaration of files must come first, then the addendum if any (see below), and then only the options. The grouping of configuration chunks is not very important, since elements are internally concatenated as strings. The following examples are all equivalent:
it: In ogni caso, questi blocchi di configurazione devono essere posizionati alla fine della riga.  La dichiarazione dei file viene prima, poi l'addendum se presente (vedere sotto), e solo poi le opzioni. Il raggruppamento dei blocchi di configurazione non è molto importante, dato che gli elementi sono internamente concatenati come stringhe. Gli esempi seguenti sono tutti equivalenti:

note: type: textblock
en: Note that language specific options are not used when building the POT file. It is for example impossible to pass B<nostrip> to the parser only when building the French translation, because the same POT file is used to update every languages. So the only options that can be language-specific are the ones that are used when producing the translation, as the C<--keep> option.
it: Si noti che le opzioni specifiche della lingua non vengono usate durante la costruzione del file POT. È per esempio impossibile passare B<nostrip> al parser solo quando crea la traduzione francese, perché lo stesso file POT viene usato per aggiornare tutte le lingue. Perciò le sole opzioni che possono essere specifiche per una lingua sono quelle che vengono usate durante la produzione della traduzione, come l'opzione C<--keep>.

note: type: =head3
en: Configuration aliases
it: Alias di configurazione

note: type: textblock
en: To pass the same options to several files, the best is to define a type alias as follows. In the next example, C<--keep 0> is passed to every Italian translation using this C<test> type, that is an extension of the C<man> type.
it: Per passare le stesse opzioni a più file, è meglio definire un alias di tipo come di seguito. Nel prossimo esempio, C<--keep 0> viene passata ad ogni traduzione italiana usando il tipo C<test>, che è un'estensione del tipo C<man>.

note: type: textblock
en: You can also extend an existing type reusing the same name for the alias as follows. This is not interpreted as as an erroneous recursive definition.
it: Si può anche estendere un tipo esistente riutilizzando lo stesso nome per l'alias come di seguito. Ciò non viene interpretato come una definizione erroneamente ricorsiva.

note: type: =head3
en: Global default options
it: Opzioni predefinite globali

note: type: textblock
en: You can also use C<[options]> lines to define options that must be used for all files, regardless of their type.
it: Si può anche usare righe di C<[options]> per definire opzioni che devono essere usate per tutti i file, indipendentemente dal loro tipo.

note: type: textblock
en: As with the command line options, you can abbreviate the parameters passed in the configuration file:
it: Come con le opzioni a riga di comando, si possono abbreviare i parametri passati nel file di configurazione:

note: type: =head3
en: Option priorities
it: Priorità delle opzioni

note: type: textblock
en: The options of every sources are concatenated, ensuring that the default values can easily be overridden by more specific options. The order is as follows:
it: Le opzioni di ogni sorgente vengono concatenate, assicurando così che i valori predefiniti possano essere facilmente ridefiniti da opzioni più specifiche. L'ordine è il seguente:

note: type: textblock
en: C<[options]> lines provide default values that can be overridden by any other source.
it: Le righe C<[options]> forniscono i valori predefiniti che possono essere ridefiniti da qualsiasi altra sorgente.

note: type: textblock
en: Type aliases are then used. Language specific settings override the ones applicable to all languages.
it: Vengono poi usati gli alias dei tipi. Le impostazioni specifiche per la lingua sovrascrivono quelle applicabili a tutte le lingue.

note: type: textblock
en: Settings that are specific to a given master file override both the default ones and the ones coming from the type alias. In this case also, language specific settings override the global ones.
it: Le impostazioni specifiche ad ogni dato file master sovrascrivono sia quelle predefinite che quelle che provengono dagli alias dei tipi. In questo caso inoltre, le impostazioni specifiche della lingua sovrascrivono quelle globali.

note: type: textblock
en: Finally, parameters provided on the B<po4a> command line override any settings from the configuration file.
it: Infine, i parametri forniti sulla riga di comando di B<po4a> sovrascrivono qualsiasi impostazione proveniente dal file di configurazione.

note: type: =head3
en: Example
it: Esempio

note: type: textblock
en: Here is an example showing how to quote the spaces and quotes:
it: Ecco un esempio che mostra come commentare gli spazi e il virgolettato:

note: type: =head2
en: Addendum: Adding extra content in the translation
it: Addendum: aggiunta di contenuto extra nella traduzione

note: type: textblock
en: If you want to add an extra section to the translation, for example to give credit to the translator, then you need to define an addendum to the line defining your master file. Please refer to the page L<po4a(7)> for more details on the syntax of addendum files.
it: Se si vuole aggiungere una sezione extra alla traduzione, per esempio per dare credito al lavoro del traduttore, allora è necessario definire un addendum alla riga che difinisce il file master. Fare riferimento alla pagina L<po4a(7)> per ulteriori dettagli sulla sintassi dei file addendum.

note: type: textblock
en: You can also use language templates as follow:
it: Si può usare anche i modelli di lingua nel modo seguente:

note: type: textblock
en: If an addendum fails to apply, the translation is discarded.
it: Se un file addendum fallisce nell'applicazione, la traduzione viene scartata.

note: type: =head3
en: Modifiers for the addendum declaration
it: Modificatori per la dichiarazione dell'addendum

note: type: textblock
en: Addendum modifiers can simplify the configuration file in the case where not all languages provide an addendum, or when the list of addenda changes from one language to the other. The modifier is a single char located before the file name.
it: I modificatori dell'addendum possono semplificare il file di configurazione nel caso in cui non tutte le lingue forniscano un addendum, o quando l'elenco degli addenda cambia da una lingua all'altra. Il modificatore è un singolo carattere posizionato prima del nome del file.

note: type: textblock
en: Include I<addendum_path> if this file does exist, otherwise do nothing.
it: Include I<addendum_path> se questo file esiste, altrimenti non fa nulla.

note: type: textblock
en: I<addendum_path> is not a regular addendum but a file containing a list of addenda, one by line.  Each addendum may be preceded by modifiers.
it: I<addendum_path> non è un un addendum normale ma un file contenente una lista di addendum, uno per riga.  Ogni addendum può essere preceduto da modificatori.

note: type: textblock
en: I<addendum_path> is discarded, it is not loaded and will not be loaded by any further addendum specification.
it: I<percorso_addendum> viene scartato, non viene caricato e non verrà caricato da nessun'altra successiva specifica di addendum.

note: type: textblock
en: The following includes an addendum in any language, but if only it exists. No error is reported if the addendum does not exist.
it: Il seguente include un addendum in ogni lingua, ma solo se questo esiste. Non viene generato nessun errore se l'addendum non esiste.

note: type: textblock
en: The following includes a list of addendum for every language:
it: Il seguente include un elenco di addendum per ogni lingua:

note: type: =head2
en: Filtering the translated strings
it: Filtro delle stringhe tradotte

note: type: textblock
en: Sometimes, you want to hide some strings from the translation process. To that extend, you can give a C<pot_in> parameter to your master file to specify the name of the file to use instead of the real master when building the POT file. Here is an example:
it: Talvolta si vorrebbe nascondere alcune stringhe dal processo di traduzione. A tale scopo, si può passare un parametro C<pot_in> al file master per specificare il nome del file da usare invece del master reale quando si crea il file POT. Ecco un esempio:

note: type: textblock
en: With this setting, the strings to translate will be extracted from the F<book-filtered.xml> (that must be produced before calling B<po4a>) while the translated files will be built from F<book.xml>. As a result, any string that is part of F<book.xml> but not in F<book-filtered.xml> will not be included in the PO files, preventing the translators from providing a translation for them. So these strings will be left unmodified when producing the translated documents.  This naturally decreases the level of translation, so you may need the C<--keep> option to ensure that the document is produced anyway.
it: Con questa impostazione, le stringhe da tradurre verranno estratte da F<book-filtered.xml> (che deve essere prodotto prima di chiamare B<po4a>) mentre i file tradotti verranno creati da F<book.xml>. Di conseguenza, qualsiasi stringa che fa parte di F<book.xml> ma non di F<book-filtered.xml> non verrà inclusa nei file PO, impedendo ai traduttori di fornire una traduzione per essi. Quindi queste stringhe non verranno modificate durante la produzione dei documenti tradotti. Questo naturalmente riduce il livello di traduzione, quindi si potrebbe aver bisogno dell'opzione C<--keep> per assicurarsi che il documento venga prodotto comunque.

note: type: =head1
en: AUTHORS
it: AUTORI

note: type: =head1
en: COPYRIGHT AND LICENSE
it: COPYRIGHT E LICENZA

note: type: textblock
en: This program is free software; you may redistribute it and/or modify it under the terms of GPL (see the COPYING file).
it: Questo programma è software libero; è lecito ridistribuirlo o modificarlo secondo i termini della licenza GPL (vedere il file COPYING).

note: type: textblock
en: po4a-gettextize - convert an original file (and its translation) to a PO file
it: po4a-gettextize - converte un documento originale (e la sua traduzione) in un file PO

note: type: textblock
en: B<po4a-gettextize> B<-f> I<fmt> B<-m> I<master.doc> B<-l> I<XX.doc> B<-p> I<XX.po>
it: B<po4a-gettextize> B<-f> I<formato> B<-m> I<master.doc> B<-l> I<XX.doc> B<-p> I<XX.po>

note: type: textblock
en: (I<XX.po> is the output, all others are inputs)
it: (I<XX.po> è l'output, tutti gli altri sono input)

note: type: textblock
en: The B<po4a-gettextize> script helps you converting your previously existing translations into a po4a-based workflow. This is only to be done once to salvage an existing translation while converting to po4a, not on a regular basis after the conversion of your project. This tedious process is explained in details in Section 'Converting a manual translation to po4a' below.
it: Lo script B<po4a-gettextize> aiuta a convertire le traduzioni già esistenti in un flusso di lavoro basato su po4a. Effettua il salvataggio della traduzione esistente in modo che sia pronta per la conversione a po4a, e quindi non serve più usarlo dopo la conversione del progetto. Questo noioso processo è spiegato in dettaglio nella sezione seguente 'Convertire la traduzione di un manuale a po4a'.

note: type: textblock
en: You must provide both a master file (e.g., the source in English) and an existing translated file (e.g., a previous translation attempt without po4a). If you provide more than one master or translation files, they will be used in sequence, but it may be easier to gettextize each page or chapter separately and then use B<msgmerge> to merge all produced PO files. As you wish.
it: È necessario fornire sia un file master (ad es. la sorgente in inglese) sia un file tradotto esistente (ad es. un precedente tentativo di traduzione senza po4a). Se si fornisce più di un file master o di traduzione, verranno utilizzati in sequenza, ma potrebbe essere più semplice gettext-izzare ciascuna pagina o capitolo separatamente e quindi utilizzare B<msgmerge> per unire tutti i file PO prodotti. Fate come volete.

note: type: textblock
en: If the master document has non-ASCII characters, the new generated PO file will be in UTF-8. If the master document is completely in ASCII, the generated PO will use the encoding of the translated input document.
it: Se il documento master contiene dei caratteri non ASCII, il file PO generato sarà in UTF-8. Se il documento master è completamente in ASCII, il PO generato userà la codifica del documento tradotto in ingresso.

note: type: textblock
en: Format of the documentation you want to handle. Use the B<--help-format> option to see the list of available formats.
it: Formato del documento in questione. L'opzione B<--help-format> mostra l'elenco dei formati disponibili.

note: type: textblock
en: File containing the master document to translate. You can use this option multiple times if you want to gettextize multiple documents.
it: Il file contenente il documento master da tradurre. Si può usare questa opzione più volte se si vuole "gettext-izzare" più documenti.

note: type: textblock
en: Charset of the file containing the document to translate.
it: Set di caratteri del file contenente il documento da tradurre.

note: type: textblock
en: File containing the localized (translated) document. If you provided multiple master files, you may wish to provide multiple localized file by using this option more than once.
it: Il file contenente la versione localizzata (tradotta) del documento. Se si hanno più documenti master, è probabile si voglia anche fornire più documenti localizzati usando quest'opzione più di una volta.

note: type: textblock
en: Charset of the file containing the localized document.
it: Set di caratteri del file contenente il documento tradotto.

note: type: textblock
en: File where the message catalog should be written. If not given, the message catalog will be written to the standard output.
it: File su cui scrivere il catalogo messaggi. Se non specificato, il catalogo messaggi viene scritto sullo standard output.

note: type: textblock
en: List the documentation formats understood by po4a.
it: Elenca i formati di documento gestiti da po4a.

note: type: textblock
en: Keep the temporary master and localized POT files built before merging.  This can be useful to understand why these files get desynchronized, leading to gettextization problems
it: Mantiene il master temporaneo e i file POT localizzati creati prima della fusione.  Può essere utile per capire perché questi file vengono desincronizzati, causando i problemi di gettex-tizzazione

note: type: =head2
en: Converting a manual translation to po4a
it: Convertire la traduzione di un manuale a po4a

note: type: textblock
en: B<po4a-gettextize> synchronizes the master and localized files to extract their content into a PO file. The content of the master file gives the B<msgid> while the content of the localized file gives the B<msgstr>. This process is somewhat fragile: the Nth string of the translated file is supposed to be the translation of the Nth string in the original.
it: B<po4a-gettextize> sincronizza il master i e file localizzati per estrarre i loro contenuti e metterli in un file PO. Il contenuto del master file produce i B<msgid> mentre i contenuti dei file localizzati danno i B<msgstr>. Questo processo è un po' fragile: la N-esima stringa del file tradotto si suppone sia la traduzione dell'N-esima stringa nell'originale.

note: type: textblock
en: Gettextization works best if you manage to retrieve the exact version of the original document that was used for translation. Even so, you may need to fiddle with both master and localized files to align their structure if it was changed by the original translator, so working on files' copies is advised.
it: La gettext-izzazione funziona meglio se si riesce a recuperare la versione esatta del documento originale che è stato utilizzato per la traduzione. Anche così, potrebbe essere necessario giocherellare con i file master e localizzati per allineare la loro struttura se è stata modificata dal traduttore originale, quindi si consiglia di lavorare su copie dei file originali.

note: type: textblock
en: Internally, each po4a parser reports the syntactical type of each extracted strings. This is how desynchronization are detected during the gettextization.  In the example depicted below, it is very unlikely that the 4th string in translation (of type 'chapter') is the translation of the 4th string in original (of type 'paragraph'). It is more likely that a new paragraph was added to the original, or that two original paragraphs were merged together in the translation.
it: Internamente, ogni analizzatore po4a riporta il tipo di sintassi di ogni stringa estratta. Questo è il modo in cui la desincronizzazione viene rilevata durante la fase di gettext-izzazione. Nell'esempio mostrato sotto, è molto improbabile che la quarta stringa nella traduzione (di tipo 'chapter') sia la traduzione della quarta stringa nell'originale (di tipo 'paragraph'). È più probabile che un nuovo paragrafo sia stato aggiunto all'originale, o che due paragrafi nell'originale siano stati fusi assieme nella traduzione.

note: type: verbatim
en:     Original         Translation
it:     Originale        Traduzione

note: type: verbatim
en:   chapter            chapter
        paragraph          paragraph
        paragraph          paragraph
        paragraph        chapter
      chapter              paragraph
        paragraph          paragraph
it:   capitolo           capitolo
        paragrafo          paragrafo
        paragrafo          paragrafo
        paragrafo        chapter
      capitolo             paragrafo
        paragrafo          paragrafo

note: type: textblock
en: B<po4a-gettextize> will verbosely diagnose any structure desynchronization. When this happens, you should manually edit the files to add fake paragraphs or remove some content here and there until the structure of both files actually match. Some tricks are given below to salvage the most of the existing translation while doing so.
it: B<po4a-gettextize> diagnostica in modo prolisso qualsiasi desincronizzazione della struttura rilevata. Quando ciò accade, è necessario modificare manualmente i file per aggiungere paragrafi falsi o rimuovere alcuni contenuti in uno dei documenti (o entrambe le cose) per correggere le disparità segnalate, fino a quando la struttura di entrambi i documenti non corrisponde perfettamente. Di seguito alcuni trucchi per recuperare il più possibile della traduzione esistente.

note: type: textblock
en: If you are lucky enough to have a perfect match in the file structures out of the box, building a correct PO file is a matter of seconds. Otherwise, you will soon understand why this process has such an ugly name :) Even so, gettextization often remains faster than translating everything again. I gettextized the French translation of the whole Perl documentation in one day despite the I<many> synchronization issues. Given the amount of text (2Mb of original text), restarting the translation without first salvaging the old translations would have required several months of work. In addition, this grunt work is the price to pay to get the comfort of po4a. Once converted, the synchronization between master documents and translations will always be fully automatic.
it: Se si è abbastanza fortunati da avere le strutture di entrambi i documenti che combaciano perfettamente, si lavorerà senza intoppi e si otterranno risultati in pochi secondi. Altrimenti, si scoprirà il perché questo processo ha un nome così brutto :). In ogni caso, la gettext-izzazione spesso è sempre più veloce che ritradurre tutto daccapo. L'autore della documentazione ha gettext-izzato l'intera traduzione della documentazione Perl in un giorno malgrado I<molti> problemi di sincronizzazione. Data la quantità di testo (2MB di testo originale), la traduzione senza il recupero delle vecchie traduzioni avrebbe richiesto diversi mesi di lavoro. Inoltre, questo brutto lavoro è il prezzo da pagare per ottenere in seguito la comodità di po4a. Una volta fatta la conversione, la sincronizzazione tra documenti master e le loro traduzioni sarà per sempre completamente automatica.

note: type: textblock
en: After a successful gettextization, the produced documents should be manually checked for undetected disparities and silent errors, as explained below.
it: Dopo una corretta gettext-izzazione, i documenti prodotti si dovrebbero controllare manualmente per le disparità non rilevate e gli errori silenziosi, come spiegato di seguito.

note: type: =head3
en: Hints and tricks for the gettextization process
it: Suggerimenti e trucchi per il processo di gettext-izzazione

note: type: textblock
en: The gettextization stops as soon as a desynchronization is detected. When this happens, you need to edit the files as much as needed to re-align the files' structures. B<po4a-gettextize> is rather verbose when things go wrong. It reports the strings that don't match, their positions in the text, and the type of each of them. Moreover, the PO file generated so far is dumped as F<gettextization.failed.po> for further inspection.
it: La gettext-izzazione si ferma non appena viene rilevata una desincronizzazione. Quando ciò accade, bisogna modificare i file quel tanto che basta per riallinearne le strutture. B<po4a-gettextize> è piuttosto prolisso quando qualcosa non funziona: indica le stringhe che non corrispondono, la loro posizione nel testo, e il tipo di ognuna di esse. Inoltre, il file PO generato fino a quel punto viene salvato in F<gettextization.failed.po> per consentirne la successiva analisi.

note: type: textblock
en: Here are some tricks to help you in this tedious process and ensure that you salvage the most of the previous translation:
it: Ecco alcuni altri trucchi per alleviare questo noioso lavoro e assicurarsi che non si distrugga buona parte del precedente lavoro di traduzione:

note: type: textblock
en: Remove all extra content of the translations, such as the section giving credits to the translators. They should be added separately to B<po4a> as addendas (see L<po4a(7)>).
it: Rimuovere tutto il contenuto extra delle traduzioni, come per esempio la sezione riconoscimenti ai traduttori. Le si potranno riaggiungere con B<po4a> in seguito, usando un'addenda (vedere L<po4a(7)>).

note: type: textblock
en: When editing the files to align their structures, prefer editing the translation if possible. Indeed, if the changes to the original are too intrusive, the old and new versions will not be matched during the first po4a run after gettextization (see below). Any unmatched translation will be dumped anyway.  That being said, you still want to edit the original document if it's too hard to get the gettextization to proceed otherwise, even if it means that one paragraph of the translation is dumped. The important thing is to get a first PO file to start with.
it: Se si sta modificando i file per allineare le loro strutture, è preferibile modificare la traduzione, se possibile. Infatti, se le modifiche all'originale sono troppe, la vecchia e la nuova versione non collimeranno durante la prima esecuzione di po4a dopo la gettext-izzazione (vedere più avanti). Ogni traduzione non corrispondente verrà comunque scaricata. Detto questo, si vorrà comunque modificare il documento originale se è troppo difficile ottenere la continuazione del processo di gettext-izzazione in altro modo, anche se ciò significherà che un paragrafo della traduzione venga gettato via. L'importante è ottenere un primo file PO con cui iniziare.

note: type: textblock
en: Do not hesitate to kill any original content that would not exist in the translated version. This content will be automatically reintroduced afterward, when synchronizing the PO file with the document.
it: Non fatevi problemi a eliminare qualsiasi contenuto originale che non esisterebbe nella versione tradotta. Questo contenuto verrà reintrodotto automaticamente in seguito, durante la sincronizzazione del file PO con il documento.

note: type: textblock
en: You should probably inform the original author of any structural change in the translation that seems justified. Issues in the original document should reported to the author. Fixing them in your translation only fixes them for a part of the community. Plus, it is impossible to do so when using po4a ;) But you probably want to wait until the end of the conversion to B<po4a> before changing the original files.
it: Si dovrebbe probabilmente informare l'autore originale di ogni cambiamento strutturale nella traduzione che sembra giustificato. Problemi nell'originale andrebbero comunicati all'autore. La correzione nella traduzione corregge solo per una parte della comunità. Inoltre è impossibile usando po4a ;). Ma è probabile si voglia aspettare la fine della conversione a B<po4a> prima di cambiare i file originali.

note: type: textblock
en: Sometimes, the paragraph content does match, but not their types. Fixing it is rather format-dependent. In POD and man, it often comes from the fact that one of them contains a line beginning with a white space while the other does not.  In those formats, such paragraph cannot be wrapped and thus become a different type. Just remove the space and you are fine. It may also be a typo in the tag name in XML.
it: A volte, il contenuto dei paragrafi corrisponde, ma i loro tipi no. La correzione è abbastanza dipendente dal formato. Nel POD e nelle pagine man, spesso deriva dal fatto che uno dei due paragrafi contiene una riga che inizia con uno spazio bianco mentre l'altro paragrafo no. In quei formati, tali paragrafi non possono essere mandati a capo e quindi diventare di un tipo diverso. In tal caso basta rimuovere lo spazio e si è a posto. Alle volte si tratta anche di un semplice refuso nel nome del marcatore XML.

note: type: textblock
en: Likewise, two paragraphs may get merged together in POD when the separating line contains some spaces, or when there is no empty line between the B<=item> line and the content of the item.
it: Allo stesso modo, due paragrafi possono venire uniti assieme nel POD quando la riga di separazione contiene alcuni spazi, o quando non c'è una riga vuota tra la riga B<=elemento> e il contenuto dell'elemento stesso.

note: type: textblock
en: Sometimes, the desynchronization message seems odd because the translation is attached to the wrong original paragraph. It is the sign of an undetected issue earlier in the process. Search for the actual desynchronization point by inspecting the file F<gettextization.failed.po> that was produced, and fix the problem where it really is.
it: A volte, il messaggio di desincronizzazione sembra strano perché la traduzione viene collegata al paragrafo originale sbagliato. È il segno di problema non rilevato prima nel processo. Cercare il punto di desincronizzazione ispezionando il file F<gettextization.failed.po> prodotto, per vedere quando inizia veramente il problema e correggerlo dov'è effettivamente.

note: type: textblock
en: Other issues may come from duplicated strings in either the original or translation. Duplicated strings are merged in PO files, with two references.  This constitutes a difficulty for the gettextization algorithm, that is a simple one to one pairing between the B<msgid>s of both the master and the localized files. It is however believed that recent versions of po4a deal properly with duplicated strings, so you should report any remaining issue that you may encounter.
it: Altri problemi possono derivare da stringhe duplicate nell'originale o nella traduzione. Le stringhe duplicate vengono fuse nei file PO, con due riferimenti. Ciò costituisce un problema per l'algoritmo di gettext-izzazione, che consiste in un semplice accoppiamento uno a uno tra i B<msgid> del file master e quelli dei file localizzati. Le versioni recenti di po4a dovrebbero però gestire correttamente le stringhe duplicate, quindi, per qualsiasi problema residuo riscontrato, si prega di segnalarlo agli sviluppatori.

note: type: =head2
en: Reviewing files produced by B<po4a-gettextize>
it: Revisione dei file prodotti da B<po4a-gettextize>

note: type: textblock
en: Any file produced by B<po4a-gettextize> should be manually reviewed, even when the script terminates successfully. You should skim over the PO file, ensuring that the B<msgid> and B<msgstr> actually match. It is not necessary to ensure that the translation is perfectly correct yet, as all entries are marked as fuzzy translations anyway. You only need to check for obvious matching issues because badly matched translations will be dumped in subsequent steps while you want to salvage them.
it: Qualsiasi file prodotto da B<po4a-gettextize> dovrebbe essere rivisto manualmente, anche quando lo script viene terminato correttamente. Si dovrebbe scorrere il file PO, assicurandosi che B<msgid> e B<msgstr> corrispondano effettivamente. Non è ancora necessario assicurarsi che la traduzione sia perfettamente corretta, poiché tutte le voci sono comunque contrassegnate come traduzioni fuzzy. Bisogna solo verificare la presenza di evidenti problemi di corrispondenza poiché le traduzioni con corrispondenza errata verranno scaricate nei passaggi successivi mentre (è probabile) si desideri salvarle.

note: type: textblock
en: Fortunately, this step does not require to master the target languages as you only want to recognize similar elements in each B<msgid> and its corresponding B<msgstr>. As a speaker of French, English, and some German myself, I can do this for all European languages at least, even if I cannot say one word of most of these languages. I sometimes manage to detect matching issues in non-Latin languages by looking at string length, phrase structures (does the amount of interrogation marks match?) and other clues, but I prefer when someone else can review those languages.
it: Fortunatamente, questo passaggio non richiede la padronanza delle lingue di destinazione poiché si desidera solo riconoscere elementi simili in ogni B<msgid> e nel corrispondente B<msgstr>. In quanto madrelingua francese, inglese e un po' di tedesco, l'autore di questa guida può farlo almeno per tutte le lingue europee, mentre non può dire una parola della maggior parte di queste lingue. A volte riesco a rilevare problemi di corrispondenza nelle lingue non latine osservando la lunghezza delle stringhe, le strutture delle frasi (la quantità di punti di interrogazione corrisponde?) e altri indizi, ma preferisco che qualcun altro riveda la traduzione di quelle lingue.

note: type: textblock
en: If you detect a mismatch, edit the original and translation files as if B<po4a-gettextize> reported an error, and try again. Once you have a decent PO file for your previous translation, backup it until you get po4a working correctly.
it: Se si rileva una mancata corrispondenza, modificare i file originale e di traduzione come se B<po4a-gettextize> segnalasse un errore e riprovare. Una volta che si ha un file PO decente per la traduzione precedente, eseguire il backup fino a quando po4a non funziona correttamente.

note: type: =head2
en: Running B<po4a> for the first time
it: Eseguire B<po4a> per la prima volta

note: type: textblock
en: The easiest way to setup po4a is to write a B<po4a.conf> configuration file, and use the integrated po4a program (B<po4a-updatepo> and B<po4a-translate> are deprecated). Please check the "CONFIGURATION FILE" Section in L<po4a(1)> documentation for more details.
it: Il modo più semplice per configurare po4a è scrivere un file di configurazione B<po4a.conf> e utilizzare il programma integrato po4a (B<po4a-updatepo> e B<po4a-translate> sono deprecati). Si prega di controllare la sezione "FILE DI CONFIGURAZIONE" nella documentazione L<po4a(1)> per maggiori dettagli.

note: type: textblock
en: When B<po4a> runs for the first time, the current version of the master documents will be used to update the PO files containing the old translations that you salvaged through gettextization. This can take quite a long time, because many of the B<msgid>s of from the gettextization do not exactly match the elements of the POT file built from the recent master files. This forces gettext to search for the closest one using a costly string proximity algorithm.  For example, the first run over the Perl documentation's French translation (5.5 MB PO file) took about 48 hours (yes, two days) while the subsequent ones only take seconds.
it: Quando B<po4a> viene eseguito per la prima volta, la versione corrente dei documenti master verrà usata per aggiornare i file PO contenenti le vecchie traduzioni salvate tramite gettext-izzazione. Ciò può richiedere molto tempo, perché molti dei B<msgid> prodotti dalla gettext-izzazione non corrispondono esattamente agli elementi del file POT creato dai file master recenti. Ciò costringe gettext a cercare quello più simile utilizzando un algoritmo computazionalmente pesante di similitudine di stringa. Ad esempio, la prima esecuzione della traduzione francese della documentazione Perl (file PO da 5,5 MB) ha richiesto circa 48 ore (sì, due giorni), mentre le successive solo pochi secondi.

note: type: =head2
en: Moving your translations to production
it: Spostare la traduzione in produzione

note: type: textblock
en: After this first run, the PO files are ready to be reviewed by translators. All entries were marked as fuzzy in the PO file by B<po4a-gettextization>, forcing their careful review before use. Translators should take each entry to verify that the salvaged translation actually match the current original text, update the translation on need, and remove the fuzzy markers.
it: Dopo questa prima esecuzione, i file PO sono pronti per essere esaminati dai traduttori. Tutte le voci sono state contrassegnate come fuzzy nel file PO dalla B<po4a-gettext-izzazione>, imponendo così la loro attenta revisione prima dell'uso. I traduttori devono: esaminare ogni voce per verificare che la traduzione salvata corrisponda effettivamente al testo originale corrente, aggiornare la traduzione ove necessario, rimuovere i marcatori fuzzy.

note: type: textblock
en: Once enough fuzzy markers are removed, B<po4a> will start generating the translation files on disk, and you're ready to move your translation workflow to production. Some projects find it useful to rely on weblate to coordinate between translators and maintainers, but that's beyond B<po4a>' scope.
it: Una volta rimossi un numero sufficiente di marcatori fuzzy, B<po4a> inizierà a generare i file di traduzione su disco e sarà il momento di spostare il flusso di lavoro di traduzione alla produzione. Alcuni progetti trovano utile affidarsi a weblate per coordinare traduttori e manutentori, ma questo va oltre lo scopo di B<po4a>.

note: type: textblock
en: po4a-normalize - normalize a documentation file by parsing it in po4a, and writing it back
it: po4a-normalize - normalizza un documento facendolo analizzare e poi riscrivere da po4a

note: type: textblock
en: B<po4a-normalize> B<-f> I<fmt> I<master.doc>
it: B<po4a-normalize> B<-f> I<formato> I<originale.doc>

note: type: textblock
en: The po4a (PO for anything) project goal is to ease translations (and more interestingly, the maintenance of translations) using gettext tools on areas where they were not expected like documentation.
it: L'obiettivo del progetto po4a (PO per tutto) è di facilitare le traduzioni (e cosa più interessante, la manutenzione delle traduzioni) usando gli strumenti associati a gettext in aree inaspettate come la documentazione.

note: type: textblock
en: The B<po4a-normalize> script is a debugging tool used to make sure that po4a don't change the document when it's not supposed to. Only use it if you're developing a new module, or if you doubt the sanity of the tools.
it: Il programma B<po4a-normalize> è uno strumento di debug usato per accertarsi che po4a non modifichi un documento quando non deve. È utile solo a chi sta sviluppando un nuovo modulo o a chi dubita dell'affidabilità di po4a.

note: type: textblock
en: The generated document will be written to F<po4a-normalize.output> while the generated POT file will be written to F<po4a-normalize.po> by default, but you can use the B<--localized> and B<--pot> options to change that.
it: Il documento generato viene scritto in F<po4a-normalize.output> mentre il file POT generato viene scritto in F<po4a-normalize.po> come impostazione predefinita, ma si possono usare le opzioni B<--localized> e B<--pot> per cambiare.

note: type: textblock
en: Create an blank translated document.  The generated translated document will be generated assuming all messages are translated by a space or new line.
it: Creare un documento tradotto vuoto.  Il documento tradotto generato verrà creato assumendo che tutti i messaggi sono tradotti da uno spazio o da un a capo.

note: type: textblock
en: This is useful to check what parts of the document cannot be translated.
it: Questo è utile per controllare quali parti del documento non possono essere tradotte.

note: type: textblock
en: Name of the normalized file to produce (I<po4a-normalize.output> by default).
it: Il nome del file normalizzato da generare (per impostazione predefinita I<po4a-normalize.output>).

note: type: textblock
en: Pot file to produce (I<po4a-normalize.po> by default).
it: Il file pot da produrre (per impostazione predefinita I<po4a-normalize.po>).

note: type: textblock
en: po4a-translate - convert a PO file back to documentation format
it: po4a-translate - converte un file PO in un documento nel formato originario

note: type: textblock
en: B<po4a-translate> B<-f> I<fmt> B<-m> I<master.doc> B<-p> I<XX.po> B<-l> I<XX.doc>
it: B<po4a-translate> B<-f> I<formato> B<-m> I<originale.doc> B<-p> I<XX.po> B<-l> I<XX.doc>

note: type: textblock
en: (I<XX.doc> is the output, all others are inputs)
it: dove I<XX.doc> è l'output e tutti gli altri sono input.

note: type: textblock
en: The B<po4a-translate> script is in charge of converting the translation (which was done in a PO file) back into the documentation format. The provided PO file should be the translation of the POT file which was produced by L<po4a-gettextize(1)>.
it: Il programma B<po4a-translate> si occupa di riconvertire la traduzione (che si trova in un file PO) nel formato d'origine. Il file PO fornito deve essere la traduzione del file POT prodotto da L<po4a-gettextize(1)>.

note: type: textblock
en: Add a file to the resulting file (to put translator's name or a section "About this translation", for example). The first line of the file to insert should be a PO4A header indicating where it should be added (see section B<HOWTO add extra text to translations> in L<po4a(7)>).
it: Aggiunge un file al documento risultante; utile per inserire, ad esempio, il nome del traduttore e altre informazioni sulla traduzione. La prima riga del file da inserire deve contenere l'header PO4A, che indica dove aggiungere il file; vedere anche la sezione B<Come si aggiunge del testo extra> in L<po4a(7)>.

note: type: textblock
en: File containing the master document to translate.
it: File contenente il documento originale da tradurre.

note: type: textblock
en: File where the localized (translated) document should be written.
it: File su cui scrivere il documento tradotto.

note: type: textblock
en: File from which the message catalog should be read.
it: File da cui leggere il catalogo messaggi.

note: type: textblock
en: Minimal threshold for translation percentage to keep (i.e. write) the resulting file (default: 80). I.e. by default, files have to be translated at least at 80% to get written.
it: Minima percentuale di traduzione richiesta affinché il file generato sia conservato e scritto su disco. Il valore predefinito è 80, vale a dire che una traduzione viene accettata solo se è completa almeno per l'80%.

note: type: textblock
en: Column at which we should wrap the resulting file.
it: Colonna a cui mandare a capo il file risultante.

note: type: textblock
en: Argument can be followed by a comma and either B<wrap> or B<nowrap> keyword.  References are written by default on a single line.  The B<wrap> option wraps references on several lines, to mimic B<gettext> tools (B<xgettext> and B<msgmerge>).  This option will become the default in a future release, because it is more sensible.  The B<nowrap> option is available so that users who want to keep the old behavior can do so.
it: L'argomento può essere seguito da una virgola e da una delle due parole chiave B<wrap> o B<nowrap>.  I riferimenti, come impostazione predefinita, vengono scritti su una singola riga.  L'opzione B<wrap> manda a capo i riferimento su più righe, per emulare il comportamento degli strumenti di B<gettext> (B<xgettext> e B<msgmerge>).  Questa opzione diventerà predefinita in una versione futura, perchè è il comportamento più logico.  L'opzione B<nowrap> è disponibile per permettere agli utenti che lo desiderassero, di mantenere il vecchio comportamento.

note: type: textblock
en: Historically, the gettext suite has reformatted the po files at the 77th column for cosmetics. This option specifies the behavior of po4a. If set to a numerical value, po4a will wrap the po file after this column and after newlines in the content. If set to B<newlines>, po4a will only split the msgid and msgstr after newlines in the content. If set to B<no>, po4a will not wrap the po file at all.  The wrapping of the reference comments is controlled by the B<--porefs> option.
it: Storicamente, la suite gettext riformattava i file po alla 77a colonna per questioni estetiche. Questa opzione specifica il comportamento di po4a. Se impostato su un valore numerico, po4a manderà a capo il file po a questo numero di colonna e dopo i caratteri di a capo nel testo. Se impostato su B<newlines>, po4a dividerà msgstr e msgstr solo dopo i caratteri di a capo nel testo. Se impostato su B<no>, po4a non metterà a capo nel testo del file po. L'andare a capo nei commenti di riferimento viene controllato dall'opzione B<--porefs>.

note: type: textblock
en: Note that this option has no impact on how the msgid and msgstr are wrapped, ie on how newlines are added to the content of these strings.
it: Si noti che questa opzione non ha alcun impatto sul modo in cui msgstr e msgstr vanno a capo, ovvero su come i caratteri di a capo vengono aggiunti al contenuto di queste stringhe.

note: type: =head1
en: Adding content (beside translations) to generated files
it: Aggiungere contenuti (oltre alle traduzioni) ai file generati

note: type: textblock
en: To add some extra content to the generated document beside what you translated (like the name of the translator, or an "About this translation" section), you should use the B<--addendum> option.
it: Per inserire dei contenuti aggiuntivi nel documento generato (come il nome del traduttore e altre informazioni sulla traduzione), usare l'opzione B<--addendum>.

note: type: textblock
en: The first line of the addendum must be a header indicating where to put it in the document (it can be before or after a given part of the document).  The rest of the file will be added verbatim to the resulting file without further processing.
it: La prima riga dell'addendum deve contenere un header, che indica la posizione in cui va inserito (può essere prima o dopo una determinata parte del documento). Il resto del file viene copiato testualmente nel documento, senza ulteriori manipolazioni.

note: type: textblock
en: Note that if po4a-translate fails to add one of the given files, it discards the whole translation (because the missing file could be the one indicating the author, what would prevent the users to contact him to report bugs in the translation).
it: Osservare che, se po4a-translate non riesce ad aggiungere anche uno solo dei file specificati, la traduzione viene scartata completamente: il file mancante potrebbe contenere il nome del traduttore e questo impedirebbe agli utenti di contattarlo per segnalare errori nella traduzione).

note: type: textblock
en: The header has a pretty rigid syntax. For more information on how to use this feature and how it works, please refer to the L<po4a(7)> man page.
it: L'header deve seguire una sintassi piuttosto rigida. Vedere anche la pagina di manuale L<po4a(7)> per maggiori informazioni sull'uso degli addenda.

note: type: textblock
en: po4a-updatepo - update the translation (in PO format) of documentation
it: po4a-updatepo - aggiorna la traduzione (in formato PO) di un documento

note: type: textblock
en: (I<XX.po> are the outputs, all others are inputs)
it: dove I<XX.po> sono output e tutti gli altri sono input.

note: type: textblock
en: The B<po4a-updatepo> script is in charge of updating PO files to make them reflect the changes made to the original documentation file. For that, it converts the documentation file to a POT file, and call L<msgmerge(1)> on this new POT and on the provided PO files.
it: Il programma B<po4a-updatepo> si occupa di aggiornare i file PO affinché riflettano le modifiche fatte ai documenti originali; per far ciò, prima converte il documento in un file POT e quindi richiama L<msgmerge(1)> su questo nuovo POT e sui file PO specificati.

note: type: textblock
en: It is possible to give more than one PO file (if you want to update several languages at once), and several documentation files (if you want to store the translations of several documents in the same PO file).
it: È possibile fornire sia più di un file PO, così da aggiornare più lingue contemporaneamente, sia diversi documenti, permettendo così di raggruppare le traduzioni di più documenti nello stesso file PO.

note: type: textblock
en: If the master document has non-ASCII characters, this script will convert the PO files to UTF-8 (if they weren't already), for a transparent handling of non-standard characters.
it: Se il documento originale contiene dei caratteri non ASCII, questo script convertirà i file PO in UTF-8 (se già non lo erano), in modo da permettere la gestione trasparente di caratteri non standard.

note: type: textblock
en: File(s) containing the master document to translate.
it: Uno o più file contenenti il documento originale da tradurre.

note: type: textblock
en: Charset of the files containing the document to translate. Note that all files must have the same charset.
it: Set di caratteri dei file contenenti il documento da tradurre. Tutti i file devono usare la stessa codifica.

note: type: textblock
en: PO file(s) to update. If these files do not exist, they are created by B<po4a-updatepo>.
it: Uno o più file PO da aggiornare. Se qualche file non esiste, verrà creato da B<po4a-updatepo>.

note: type: textblock
en: This option removes B<--previous> from the options passed to B<msgmerge>.  This helps supporting old versions of B<gettext> (before v0.16).
it: Questa opzione rimuove B<--previous> dalle opzioni passate a B<msgmerge>.  Ciò aiuta a supportare le vecchie versioni di B<gettext> (precedenti la 0.16).

note: type: textblock
en: msguntypot - update PO files when a typo is fixed in POT file
it: msguntypot - aggiorna il file PO quando un errore tipografico viene corretto nel file POT

note: type: textblock
en: B<msguntypot> B<-o> I<old_pot> B<-n> I<new_pot> I<pofiles> ...
it: B<msguntypot> B<-o> I<vecchio_pot> B<-n> I<nuovo_pot> I<file_po> ...

note: type: textblock
en: When you fix a trivial error which surely doesn't affect translations (e.g.  a typo) in a POT file, you should unfuzzy the corresponding msgstr in the translated PO files to avoid so extra work to the translators.
it: Quando si sitema un errore banale che sicuramente non influisce sulle traduzioni (per es. un errore di battitura) in un file POT, si dovrebbe de-fuzzy-are le corrispondenti msgstr nei file PO tradotti in modo da evitare lavoro extra ai traduttori.

note: type: textblock
en: This task is difficult and error prone when done manually, and this tool is there to help doing so correctly. You just need to provide the two versions of the POT file: before the edition and after as marked in the above synopsis, and it all becomes automatic.
it: Questo compito è difficoltoso e porta facilmente a commettere degli errori se eseguito manualmente, e questo strumento esiste proprio per aiutare ad eseguirlo correttamente. Basta solo fornire le due versioni del file POT: prima della modifica e dopo come impostato nella sintassi descritta sopra, e tutto diventa automatico.

note: type: =head1
en: HOW TO USE IT
it: COME USARLO

note: type: textblock
en: In short, when you discover a typo in one of your [english] message, do the following:
it: In breve, quando si scopre un errore di battitura in oneuno dei messaggi [in inglese], fare le operazioni seguenti:

note: type: =item
en: - Regenerate your POT and PO files.
it: - Rigenerare i file POT e PO.

note: type: verbatim
en:   make -C po/ update-po # for message program translations
      debconf-updatepo      # for debconf translations
      po4a po4a.conf        # for po4a based documentation translations
it:   make -C po/ update-po # per traduzioni di messaggi di programmi
      debconf-updatepo      # per traduzioni di debconf
      po4a po4a.conf        # per traduzioni di documentazione basata su po4a

note: type: textblock
en: or something else, depending on your project's building settings. You know how to make sure your POT and PO files are uptodate, don't you??
it: o qualcos'altro, a seconda delle impostazioni di compilazione del progetto. Sapete come assicurarvi che i file POT e PO siano aggiornati, non è vero?

note: type: =item
en: - Make a copy of your POT file.
it: - Fare una copia del file POT.

note: type: =item
en: - Make a copy of all your PO files.
it: - Fare una copia di tutti i file PO.

note: type: =item
en: - Fix your typo.
it: - Sistemare l'errore.

note: type: textblock
en: $EDITOR the_file_in_which_there_is_a_typo
it: $EDITOR il_file_nel_quale_c'è_un_errore_di_battitura

note: type: textblock
en: See above.
it: Vedere sopra.

note: type: textblock
en: At this point, the typo fix fuzzied all the translations, and this unfortunate change is the only one between the PO files of your main directory and the one from the fridge. Here is how to solve this.
it: A questo punto, la correzione dell'errore di battitura ha reso fuzzy tutte le traduzioni, e questo sfortunato cambiamento è l'unico tra i file PO della cartella principale e quella del frigo. Ecco come risolvere il problema.

note: type: =item
en: - Discard fuzzy translation, restore the ones from the fridge.
it: - Scartare le traduzioni fuzzy, ripristinare quelle dal frigo.

note: type: =item
en: - Manually merge the PO files with the new POT file, but taking the useless fuzzy into account.
it: - Fondere manualmente i file PO con il nuovo file POT, ma tenendo conto delle fuzzy inutili.

note: type: =item
en: - Cleanups.
it: - Pulizie.

note: type: textblock
en: You're done. The typo was eradicated from msgstr of both your POT and PO files, and the PO files were not fuzzyied in the process. Your translators love you already.
it: Finito. L'errore di battitura è stato sradicato dai msgstr sia del POT che dei file PO, e i file PO non sono stati "fuzzificati" durante il processo. I traduttori ti adoreranno.

note: type: textblock
en: Despite its name, this tool is not part of the gettext tool suite. It is instead part of po4a. More precisely, it's a random Perl script using the fine po4a modules. For more information about po4a, please see:
it: Malgrado il suo nome, questo strumento non fa parte della suite gettext. Fa invece parte di po4a. Più precisamente, è uno script Perl che usa i moduli po4a. Per ulteriori informazioni su po4a, consultare:

note: type: textblock
en: Copyright 2005 by SPI, inc.
it: Copyright © 2005 by SPI, inc.

note: type: textblock
en: po4a - framework to translate documentation and other materials
it: po4a - framework per la traduzione di documentazione e altro materiale

note: type: =head1
en: Introduction
it: Introduzione

note: type: textblock
en: po4a (PO for anything) eases the maintenance of documentation translation using the classical gettext tools. The main feature of po4a is that it decouples the translation of content from its document structure.
it: po4a (PO per tutto) facilita la manutenzione della traduzione della documentazione utilizzando i classici strumenti gettext. La caratteristica principale di po4a è che separa la traduzione dei contenuti dalla struttura del documento stesso.

note: type: textblock
en: This document serves as an introduction to the po4a project with a focus on potential users considering whether to use this tool and on the curious wanting to understand why things are the way they are.
it: Questo documento serve da introduzione al progetto po4a, concentrandosi sui potenziali utenti di questo strumento e sui curiosi che vogliono capire come funziona ed il suo scopo.

note: type: =head1
en: Why po4a?
it: Perché po4a?

note: type: textblock
en: The philosophy of Free Software is to make the technology truly available to everyone. But licensing is not the only consideration: untranslated free software is useless for non-English speakers. Therefore, we still have some work to do to make software available to everybody.
it: La filosofia del software libero è di rendere la tecnologia veramente accessibile a tutti. Ma le licenze non sono l'unico problema: programmi liberi ma non tradotti sono inutili a chi non parla inglese. Pertanto c'è ancora del lavoro da fare per rendere il software accessibile a tutti.

note: type: textblock
en: This situation is well understood by most projects and everybody is now convinced of the necessity to translate everything. Yet, the actual translations represent a huge effort of many individuals, crippled by small technical difficulties.
it: Questa situazione è ben compresa dalla maggior parte dei progetti e tutti sono ormai convinti della necessità di tradurre tutto. Eppure, le traduzioni attuali rappresentano un enorme sforzo per molti individui, paralizzate da piccole difficoltà tecniche.

note: type: textblock
en: Thankfully, Open Source software is actually very well translated using the gettext tool suite. These tools are used to extract the strings to translate from a program and present the strings to translate in a standardized format (called PO files, or translation catalogs). A whole ecosystem of tools has emerged to help the translators actually translate these PO files. The result is then used by gettext at run time to display translated messages to the end users.
it: Fortunatamente, il software open source attualmente gode di un buon livello di traduzione, grazie alla splendida suite gettext. Gli strumenti di questa suite vengono usati per estrarre le stringhe da tradurre dai programmi e presentarle ai traduttori un formato standard (chiamato file PO, o catalogo di traduzioni). Da ciò è nato un intero ecosistema di strumenti di aiuto ai traduttori per la traduzione di questi file PO. Il risultato viene poi usato durante l'esecuzione da gettext per mostrare i messaggi tradotti all'utente finale.

note: type: textblock
en: Regarding documentation, however, the situation still somewhat disappointing.  At first translating documentation may seem to be easier than translating a program as it would seem that you just have to copy the documentation source file and start translating the content. However, when the original documentation is modified, keeping track of the modifications quickly turns into a nightmare for the translators. If done manually, this task is unpleasant and error prone.
it: Per quanto riguarda la documentazione, invece, la situazione è ancora alquanto deludente. All'inizio tradurre la documentazione può sembrare più facile che tradurre un programma in quanto sembrerebbe che devi solo copiare il file sorgente della documentazione e iniziare a tradurre il contenuto. Tuttavia, quando la documentazione originale viene modificata, tenere traccia delle modifiche si trasforma rapidamente in un incubo per i traduttori. Se eseguita manualmente, questa attività è spiacevole e soggetta a errori.

note: type: textblock
en: Outdated translations are often worse than no translation at all. End-users can be tricked by documentation describing an old behavior of the program.  Furthermore, they cannot interact directly with the maintainers since they don't speak English. Additionally, the maintainer cannot fix the problem as they don't know every language in which their documentation is translated.  These difficulties, often caused by poor tooling, can undermine the motivation of volunteer translators, further aggravating the problem.
it: Le traduzioni obsolete sono spesso peggio di nessuna traduzione. Gli utenti finali possono essere ingannati dalla documentazione che descrive un vecchio comportamento del programma. Inoltre, non possono interagire direttamente con i manutentori poiché non parlano inglese. Inoltre, il manutentore non può risolvere il problema poiché non conosce tutte le lingue in cui è tradotta la documentazione. Queste difficoltà, spesso causate da una strumentazione scarsa, possono minare la motivazione dei traduttori volontari, aggravando ulteriormente il problema.

note: type: textblock
en: B<The goal of the po4a project is to ease the work of documentation translators>.  In particular, it makes documentation translations I<maintainable>.
it: B<L'obiettivo del progetto po4a è facilitare il lavoro dei traduttori di documentazione>. In particolare, rende le traduzioni della documentazione I<manutenibili>.

note: type: textblock
en: The idea is to reuse and adapt the gettext approach to this field. As with gettext, texts are extracted from their original locations and presented to translators as PO translation catalogs. The translators can leverage the classical gettext tools to monitor the work to do, collaborate and organize as teams. po4a then injects the translations directly into the documentation structure to produce translated source files that can be processed and distributed just like the English files. Any paragraph that is not translated is left in English in the resulting document, ensuring that the end users never see an outdated translation in the documentation.
it: L'idea è di riutilizzare e adattare l'approccio gettext a questo campo. Come con gettext, i testi vengono estratti dalle loro posizioni originali e presentati ai traduttori come cataloghi di traduzione PO. I traduttori possono sfruttare i classici strumenti gettext per monitorare il lavoro da fare, collaborare e organizzarsi come squadra di traduzione. po4a quindi inserisce le traduzioni direttamente nella struttura della documentazione per produrre file sorgente tradotti che possono essere elaborati e distribuiti proprio come i file inglesi. Qualsiasi paragrafo non tradotto viene lasciato in inglese nel documento risultante, assicurando che gli utenti finali non vedano mai una traduzione obsoleta nella documentazione.

note: type: textblock
en: This automates most of the grunt work of the translation maintenance.  Discovering the paragraphs needing an update becomes very easy, and the process is completely automated when elements are reordered without further modification. Specific verification can also be used to reduce the chance of formatting errors that would result in a broken document.
it: Ciò automatizza la maggior parte del lavoro oneroso della manutenzione della traduzione. La scoperta dei paragrafi che necessitano di un aggiornamento diventa molto semplice e il processo è completamente automatizzato quando gli elementi vengono riordinati senza ulteriori modifiche. È inoltre possibile utilizzare una verifica specifica per ridurre la possibilità di errori di formattazione che potrebbero causare il rovinarsi del documento.

note: type: textblock
en: Please also see the B<FAQ> below in this document for a more complete list of the advantages and disadvantages of this approach.
it: Consultare la B<FAQ> più avanti in questo documento per avere un elenco completo di vantaggi e svantaggi di questo approccio.

note: type: =head2
en: Supported formats
it: Formati supportati

note: type: textblock
en: Currently, this approach has been successfully implemented to several kinds of text formatting formats:
it: Attualmente, questo approccio è stato realizzato con successo per diversi formati di documenti di testo:

note: type: =item
en: man (mature parser)
it: man (parser maturo)

note: type: textblock
en: The good old manual pages' format, used by so many programs out there. po4a support is very welcome here since this format is somewhat difficult to use and not really friendly to newbies.
it: Il buon vecchio formato delle pagine man, usato da così tanti programmi in circolazione. Il supporto di po4a è sicuramente benvenuto, dal momento che questo formato è alquanto difficile da usare direttamente e non è esattamente amichevole per i principianti.

note: type: textblock
en: The L<Locale::Po4a::Man(3pm)|Man> module also supports the mdoc format, used by the BSD man pages (they are also quite common on Linux).
it: Il modulo L<Locale::Po4a::Man(3pm)|Man> supporta anche il formato mdoc, usato dalle pagine man BSD (sono anche abbastanza comuni su Linux).

note: type: =item
en: AsciiDoc (mature parser)
it: AsciiDoc (parser maturo)

note: type: textblock
en: This format is a lightweight markup format intended to ease the authoring of documentation. It is for example used to document the git system. Those manpages are translated using po4a.
it: Questo formato è un formato di markup leggero inteso a facilitare la creazione della documentazione. Ad esempio, viene utilizzato per documentare il sistema git. Tali pagine man sono tradotte usando po4a.

note: type: textblock
en: See L<Locale::Po4a::AsciiDoc> for details.
it: Consultare L<Locale::Po4a::AsciiDoc> per i dettagli.

note: type: =item
en: pod (mature parser)
it: pod (parser maturo)

note: type: textblock
en: This is the Perl Online Documentation format. The language and extensions themselves are documented using this format in addition to most existing Perl scripts. It makes easy to keep the documentation close to the actual code by embedding them both in the same file. It makes programmer's life easier, but unfortunately, not the translator's, until you use po4a.
it: Questo è il formato della documentazione online di Perl. Il linguaggio e le sue estensioni sono documentate in questo modo, così come molti degli script Perl esistenti. Inglobando entrambi nello stesso file è più facile mantenere la documentazione, essendo vicina al codice corrispondente. Rende la vita più semplice al programmatore, ma sfortunatamente non al traduttore, finché non si usa po4a.

note: type: textblock
en: See L<Locale::Po4a::Pod> for details.
it: Consultare L<Locale::Po4a::Pod> per i dettagli.

note: type: =item
en: sgml (mature parser)
it: sgml (parser maturo)

note: type: textblock
en: Even if superseded by XML nowadays, this format is still used for documents which are more than a few screens long. It can even be used for complete books.  Documents of this length can be very challenging to update. B<diff> often reveals useless when the original text was re-indented after update.  Fortunately, po4a can help you after that process.
it: Anche se oggigiorno è stato in qualche modo superato da XML, questo formato è ancora molto spesso usato per documenti più lunghi di qualche schermata. Può essere usato anche per interi libri. Documenti così lunghi possono rilevarsi ardui da aggiornare. Strumenti come B<diff> si rivelano spesso inutili quando il testo originale è stato re-indentato dopo l'aggiormanento. Fortunatamente, po4a può aiutare dopo questo processo.

note: type: textblock
en: Currently, only DebianDoc and DocBook DTD are supported, but adding support for a new one is really easy. It is even possible to use po4a on an unknown SGML DTD without changing the code by providing the needed information on the command line. See L<Locale::Po4a::Sgml(3pm)> for details.
it: Al momento sono supportati solo i DTD DebianDoc e DocBook, ma aggiungere il supporto a nuovi (DTD) è molto facile. È perfino possibile usare po4a su un DTD SGML sconosciuto senza modificarne il codice, basta fornire le informazioni necessarie dalla riga di comando. Consultare L<Locale::Po4a::Sgml(3pm)> per i dettagli.

note: type: =item
en: TeX / LaTeX (mature parser)
it: TeX / LaTeX (parser maturo)

note: type: textblock
en: The LaTeX format is a major documentation format used in the Free Software world and for publications.
it: Il formato LaTeX è un formato di documentazione importante usato dal mondo del Free Software e da diverse pubblicazioni.

note: type: textblock
en: The L<Locale::Po4a::LaTeX(3pm)|LaTeX> module was tested with the Python documentation, a book and some presentations.
it: Il modulo L<Locale::Po4a::LaTeX(3pm)|LaTeX> è stato testato con la documentazione Python, un libro e alcune presentazioni.

note: type: =item
en: text (mature parser)
it: text (parser maturo)

note: type: textblock
en: The Text format is the base format for many formats that include long blocks of text, including Markdown, fortunes, YAML front matter section, debian/changelog, and debian/control.
it: Il formato text (testo) è il formato base per molti formati che includono lunghi blocchi di testo, inclusi Markdown, fortunes, YAML front matter section, debian/changelog, e debian/control.

note: type: textblock
en: This supports the common format used in Static Site Generators, READMEs, and other documentation systems. See L<Locale::Po4a::Text(3pm)|Text> for details.
it: Questo supporta il generico formato usato nei generatori di siti statici, nei file README (LEGGIMI), e altri sistemi di documentazione.  Vedere L<Locale::Po4a::Text(3pm)|Text> per i dettagli.

note: type: =item
en: xml and XHMTL (probably mature parser)
it: xml e XHMTL (parser probabilmente maturo)

note: type: textblock
en: The XML format is a base format for many documentation formats.
it: Il formato XML è un formato base per molti formati di documentazione.

note: type: textblock
en: Currently, the DocBook DTD (see L<Locale::Po4a::Docbook(3pm)> for details) and XHTML are supported by po4a.
it: Attualmente, il DTD DocBook (consultare L<Locale::Po4a::Docbook(3pm)> per i dettagli) e XHTML sono supportati da po4a.

note: type: =item
en: BibTex (probably mature parser)
it: BibTex (parser probabilmente maturo)

note: type: textblock
en: The BibTex format is used alongside LaTex for formatting lists of references (bibliographies).
it: Il formato BibTex viene usato assieme a LaTex per la formattazione di elenchi di riferimenti bibliografici.

note: type: textblock
en: See L<Locale::Po4a::BibTex> for details.
it: Consultare L<Locale::Po4a::BibTex> per i dettagli.

note: type: =item
en: Docbook (probably mature parser)
it: Docbook (parser probabilmente maturo)

note: type: textblock
en: A XML-based markup language that uses semantic tags to describe documents.
it: Un linguaggio a marcatori basato su XML che usa etichette semantiche per descrivere i documenti.

note: type: textblock
en: See L<Locale::Po4a:Docbook> for greater details.
it: Consultare L<Locale::Po4a:Docbook> per ulteriori dettagli.

note: type: =item
en: Guide XML (probably mature parser)
it: Guide XML (parser probabilmente maturo)

note: type: textblock
en: A XML documentation format. This module was developed specifically to help with supporting and maintaining translations of Gentoo Linux documentation up until at least March 2016 (Based on the Wayback Machine). Gentoo have since moved to the DevBook XML format.
it: Un formato di documentazione XML. Questo modulo è stato sviluppato specificamente per supportare e mantenere le traduzioni della documentazione di Gentoo Linux almeno fino a marzo 2016 (secondo Wayback Machine). Da allora Gentoo è passato al formato DevBook XML.

note: type: textblock
en: See L<Locale::Po4a:Guide> for greater details.
it: Consultare L<Locale::Po4a:Guide> per maggiori dettagli.

note: type: =item
en: Wml (probably mature parser)
it: Wml (parser probabilmente maturo)

note: type: textblock
en: The Web Markup Language, do not mixup WML with the WAP stuff used on cell phones.  This module relies on the Xhtml module, which itself relies on the XmL module.
it: Il Web Markup Language, da non confondere il WML con la roba WAP usata (N.d.T. soprattutto in passato) sui telefoni cellulari. Questo modulo si basa sul modulo Xhtml, che a sua volta si basa sul modulo XmL.

note: type: textblock
en: See L<Locale::Po4a::Wml> for greater details.
it: Consultare L<Locale::Po4a::Wml> per maggiori dettagli.

note: type: =item
en: Yaml (probably mature parser)
it: Yaml (parser probabilmente maturo)

note: type: textblock
en: A strict superset of JSON. YAML is often used as systems or configuration projects.  YAML is at the core of Red Hat's Ansible.
it: Un soprainsieme di JSON, YAML viene spesso usato per progetti sistemistici o per configurazione. YAML è centrale per il sistema di Red Hat Ansible.

note: type: textblock
en: See L<Locale::Po4a::Yaml> for greater details.
it: See L<Locale::Po4A::Yaml> for greater details.

note: type: =item
en: RubyDoc (probably mature parser)
it: RubyDoc (parser probabilmente maturo)

note: type: textblock
en: The Ruby Document (RD) format, originally the default documentation format for Ruby and Ruby projects before converted to RDoc in 2002. Though apparently the Japanese version of the Ruby Reference Manual still use RD.
it: Il formato Ruby Document (RD), originariamente il formato di documentazione predefinito per Ruby e per i progetti Ruby prima di essere convertito in RDoc nel 2002. Anche se apparentemente la versione giapponese del Ruby Reference Manual usa ancora RD.

note: type: textblock
en: See L<Locale::Po4a::RubyDoc> for greater details.
it: Consultare L<Locale::Po4a::RubyDoc> per maggiori dettagli.

note: type: =item
en: Halibut (probably experimental parser)
it: Halibut (parser probabilmente sperimentale)

note: type: textblock
en: A documentation production system, with elements similar to TeX, debiandoc-sgml, TeXinfo, and others, developed by Simon Tatham, the developer of PuTTY.
it: Un sistema di produzione di documentazione, con elementi simili a TeX, debiandoc-sgml, TeXinfo e altri, sviluppato da Simon Tatham, lo sviluppatore di PuTTY.

note: type: textblock
en: See L<Locale::Po4a:Halibut> for greater details.
it: Consultare L<Locale::Po4a:Halibut> per maggiori dettagli.

note: type: =item
en: Ini (probably experimental parser)
it: Ini (parser probabilmente sperimentale)

note: type: textblock
en: Configuration file format popularized by MS-DOS.
it: Formato di file di configurazione reso popolare da MS-DOS.

note: type: textblock
en: See L<Locale::Po4a::Ini> for greater details.
it: Consultare L<Locale::Po4a::Ini> per maggiori dettagli.

note: type: =item
en: texinfo (very highly experimental parser)
it: texinfo (parser molto sperimentale)

note: type: textblock
en: All of the GNU documentation is written in this format (it's even one of the requirements to become an official GNU project). The support for L<Locale::Po4a::Texinfo(3pm)|Texinfo> in po4a is still at the beginning.  Please report bugs and feature requests.
it: Tutta la documentazione GNU è stata scritta in questo formato (è persino uno dei requisiti per i progetto ufficiali GNU). Il supporto per L<Locale::Po4a::Texinfo(3pm)|Texinfo> in po4a è ancora agli inizi. Si prega di segnalare eventuali difetti e richieste di miglioramenti.

note: type: =item
en: Others supported formats
it: Altri formati supportati

note: type: textblock
en: Po4a can also handle some more rare or specialized formats, such as the documentation of compilation options for the 2.4+ Linux kernels (L<Locale::Po4a::KernelHelp>) or the diagrams produced by the dia tool (L<Locale::Po4a:Dia>). Adding a new format is often very easy and the main task is to come up with a parser for your target format. See L<Locale::Po4a::TransTractor(3pm)> for more information about this.
it: Po4a può anche gestire qualche altro formato raro o di uso specifico, come la documentazione delle opzioni di compilazione dei kernel 2.4+(L<Locale::Po4a::KernelHelp>), oppure i diagrammi prodotti dal programma Dia(L<Locale::Po4a::Dia>). Aggiungere un nuovo formato è spesso molto facile e il grosso del lavoro è produrre un parser per il formato scelto. Per maggiori informazioni su questo argomento, consultare L<Locale::Po4a::TransTractor(3pm)>.

note: type: =item
en: Unsupported formats
it: Formati non supportati

note: type: textblock
en: Unfortunately, po4a still lacks support for several documentation formats. Many of them would be easy to support in po4a. This includes formats not just used for documentation, such as, package descriptions (deb and rpm), package installation scripts questions, package changelogs, and all the specialized file formats used by programs such as game scenarios or wine resource files.
it: Sfortunatamente, a po4a manca il supporto per diversi formati di documentazione. Molti di questi non sarebbero facili da supportare. Questi includono formati non solo di documentazione come le descrizioni dei pacchetti (deb e rpm), le domande poste dagli script di installazione dei pacchetti, i changelog dei pacchetti e tutti i formati specializzati usati da vari programmi, come gli scenari dei giochi o i file delle risorse di wine.

note: type: =head1
en: Using po4a
it: Uso di po4a

note: type: textblock
en: Historically, po4a was built around four scripts, each fulfilling a specific task. L<po4a-gettextize(1)> helps bootstrapping translations and optionally converting existing translation projects to po4a. L<po4a-updatepo(1)> reflects the changes to the original documentation into the corresponding po files.  L<po4a-translate(1)> builds translated source file from the original file and the corresponding PO file. In addition, L<po4a-normalize(1)> is mostly useful to debug the po4a parsers, as it produces an untranslated document from the original one. It makes it easier to spot the glitches introduced by the parsing process.
it: Storicamente, po4a è stato costruito attorno a quattro script, ognuno dei quali svolgeva un compito specifico. L<po4a-gettextize(1)> aiuta nell'avvio delle traduzioni e opzionalmente a convertire i progetti di traduzione esistenti in po4a. L<po4a-updatepo(1)> riporta le modifiche alla documentazione originale nei corrispondenti file po. L<po4a-translate(1)> crea il file sorgente tradotto dal file originale e dal corrispondente file PO. Infine, L<po4a-normalize(1)> è utile principalmente per eseguire il debug dei parser po4a, poiché produce un documento non tradotto da quello originale. Rende più facile individuare i piccoli difetti introdotti dal processo di analisi.

note: type: textblock
en: Most projects only require the features of L<po4a-updatepo(1)> and L<po4a-translate(1)>, but these scripts proved to be cumbersome and error prone to use. If the documentation to translate is split over several source files, it is difficult to keep the PO files up to date and build the documentation files correctly. As an answer, a all-in-one tool was provided: L<po4a(1)>. This tool takes a configuration file describing the structure of the translation project: the location of the PO files, the list of files to translate, and the options to use, and it fully automates the process. When you invoke L<po4a(1)>, it both updates the PO files and regenerate the translation files that need to. If everything is already up to date, L<po4a(1)> does not change any file.
it: La maggior parte dei progetti richiede solo le funzionalità di L<po4a-updatepo(1)> e L<po4a-translate(1)>, ma questi script si sono dimostrati macchinosi e soggetti a errori nell'uso. Se la documentazione da tradurre è suddivisa in più file origine, è difficile mantenere aggiornati i file PO e creare correttamente i file di documentazione. In risposta a questo problema, è stato fornito uno strumento omnicomprensivo: L<po4a(1)>. Questo strumento utilizza un file di configurazione che descrive la struttura del progetto di traduzione: la posizione dei file PO, l'elenco dei file da tradurre e le opzioni da utilizzare, automatizzando completamente il processo. Quando si esegue L<po4a(1)>, esso aggiorna i file PO e rigenera i file di traduzione necessari. Se è tutto già aggiornato, L<po4a(1)> non cambia alcun file.

note: type: textblock
en: The rest of this section gives an overview of how use the scripts' interface of po4a. Most users will probably prefer to use the all-in-one tool, that is described in the documentation of L<po4a(1)>.
it: Il resto di questa sezione fornisce una panoramica su come utilizzare l'interfaccia degli script di po4a. La maggior parte degli utenti preferirà probabilmente utilizzare lo strumento omnicomprensivo, descritto nella documentazione di L<po4a(1)>.

note: type: =head2
en: Graphical overview of the po4a scripts
it: Panoramica grafica degli script po4a

note: type: textblock
en: The following schema gives an overview of how each po4a script can be used.  Here, F<master.doc> is an example name for the documentation to be translated; F<XX.doc> is the same document translated in the language XX while F<doc.XX.po> is the translation catalog for that document in the XX language. Documentation authors will mostly be concerned with F<master.doc> (which can be a manpage, an XML document, an asciidoc file or similar); the translators will be mostly concerned with the PO file, while the end users will only see the F<XX.doc> file.
it: Il seguente schema offre una panoramica di come ogni script po4a può essere utilizzato. Qui, F<master.doc> è un nome di esempio per la documentazione da tradurre; F<XX.doc> è lo stesso documento tradotto nella lingua XX mentre F<doc.XX.po> è il catalogo di traduzione per quel documento nella lingua XX. Gli autori della documentazione si occuperanno principalmente di F<master.doc> (che può essere una pagina man, un documento XML, un file asciidoc o simile); i traduttori si occuperanno principalmente del file PO, mentre gli utenti finali vedranno solo il file F<XX.doc>.

note: type: verbatim
en:                                    master.doc
                                           |
                                           V
         +<-----<----+<-----<-----<--------+------->-------->-------+
         :           |                     |                        :
    {translation}    |         { update of master.doc }             :
         :           |                     |                        :
       XX.doc        |                     V                        V
     (optional)      |                 master.doc ->-------->------>+
         :           |                   (new)                      |
         V           V                     |                        |
      [po4a-gettextize]   doc.XX.po -->+   |                        |
              |            (old)       |   |                        |
              |              ^         V   V                        |
              |              |     [po4a-updatepo]                  |
              V              |           |                          V
       translation.pot       ^           V                          |
              |              |        doc.XX.po                     |
              |              |         (fuzzy)                      |
       { translation }       |           |                          |
              |              ^           V                          V
              |              |     {manual editing}                 |
              |              |           |                          |
              V              |           V                          V
          doc.XX.po --->---->+<---<-- doc.XX.po    addendum     master.doc
          (initial)                 (up-to-date)  (optional)   (up-to-date)
              :                          |            |             |
              :                          V            |             |
              +----->----->----->------> +            |             |
                                         |            |             |
                                         V            V             V
                                         +------>-----+------<------+
                                                      |
                                                      V
                                               [po4a-translate]
                                                      |
                                                      V
                                                    XX.doc
                                                 (up-to-date)
it:                                    master.doc
                                           |
                                           V
         +<-----<----+<-----<-----<--------+------->-------->-------+
         :           |                     |                        :
    {traduzione}     |      { aggiornamento di master.doc }         :
         :           |                     |                        :
       XX.doc        |                     V                        V
     (opzionale)     |                 master.doc ->-------->------>+
         :           |                  (nuovo)                     |
         V           V                     |                        |
      [po4a-gettextize]  doc.XX.po -->+    |                        |
              |          (vecchio)    |    |                        |
              |              ^        V    V                        |
              |              |     [po4a-updatepo]                  |
              V              |           |                          V
       translation.pot       ^           V                          |
              |              |       doc.XX.po                      |
              |              |        (fuzzy)                       |
       { traduzione }        |           |                          |
              |              ^           V                          V
              |              |   {modifica manuale}                 |
              |              |           |                          |
              V              |           V                          V
          doc.XX.po --->---->+<---<-- doc.XX.po    addendum     master.doc
          (iniziale)                (aggiornato)  (opzionale)  (aggiornato)
              :                          |            |             |
              :                          V            |             |
              +----->----->----->------> +            |             |
                                         |            |             |
                                         V            V             V
                                         +------>-----+------<------+
                                                      |
                                                      V
                                               [po4a-translate]
                                                      |
                                                      V
                                                    XX.doc
                                                 (aggiornato)

note: type: textblock
en: This schema is complicated, but in practice only the right part (involving L<po4a-updatepo(1)> and L<po4a-translate(1)>) is used once the project is setup and configured.
it: Questo schema è complicato, ma in pratica solo la parte destra (che coinvolge L<po4a-updatepo(1)> e L<po4a-translate(1)>) viene utilizzata, una volta impostato e configurato il progetto.

note: type: textblock
en: The left part depicts how L<po4a-gettextize(1)> can be used to convert an existing translation project to the po4a infrastructure. This script takes an original document and its translated counterpart, and tries to build the corresponding PO file. Such manual conversion is rather cumbersome (see the L<po4a-gettextize(1)> documentation for more details), but it is only needed once to convert your existing translations. If you don't have any translation to convert, you can forget about this and focus on the right part of the schema.
it: La parte sinistra mostra come L<po4a-gettextize(1)> può essere usato per convertire un progetto di traduzione esistente verso l'infrastruttura po4a. Questo script prende un documento originale e la sua associata parte tradotta e cerca di creare il file PO corrispondente. Tale conversione manuale è piuttosto complicata (vedere la documentazione di L<po4a-gettextize(1)> per maggiori dettagli), ma è necessaria solo una volta per convertire le traduzioni esistenti. Se non si ha alcuna traduzione da convertire, si può dimenticarsene e concentrarsi solo sulla parte destra dello schema.

note: type: textblock
en: On the top right part, the action of the original author is depicted, updating the documentation. The middle right part depicts the automatic actions of L<po4a-updatepo(1)>. The new material is extracted and compared against the exiting translation. The previous translation is used for the parts that didn't change, while partially modified parts are connected to the previous translation with a "fuzzy" marker indicating that the translation must be updated. New or heavily modified material is left untranslated.
it: In alto a destra, viene illustrata l'azione dell'autore originale che aggiorna la documentazione. Nel centro della parte destra, sono raffigurate le azioni automatiche di L<po4a-updatepo(1)>. Il nuovo materiale viene estratto e confrontato con la traduzione esistente. La traduzione precedente viene usata per le parti che non sono cambiate. Le parti parzialmente modificate vengono associate alla traduzione precedente, ma con la marcatura "fuzzy" indicante che la traduzione necessita di aggiornamento. Il materiale nuovo o completamente modificato viene lasciato non tradotto.

note: type: textblock
en: Then, the I<manual editing> reported depicts the action of the translators, that modify the PO files to provide translations to every original string and paragraph. This can be done using either a specific editor such as the B<GNOME Translation Editor>, KDE's B<Lokalize> or B<poedit>, or using an online localization platform such as B<weblate> or B<pootle>. The translation result is a set of PO files, one per language. Please refer to the gettext documentation for more details.
it: Quindi, la I<modifica manuale> riportata, descrive l'azione dei traduttori, che modificano i file PO per fornire traduzioni per ogni stringa e paragrafo originali. Ciò può essere effettuato utilizzando un editor specifico come lo B<GNOME Translation Editor>, B<Lokalize> di KDE o B<poedit> o utilizzando una piattaforma di traduzione sul web come B<weblate> o B<pootle>. Il risultato della traduzione è un insieme di file PO, uno per lingua. Fare riferimento alla documentazione di gettext per maggiori dettagli.

note: type: textblock
en: The bottom part of the figure shows how L<po4a-translate(1)> creates a translated source document from the F<master.doc> original document and the F<doc.XX.po> translation catalog that was updated by the translators. The structure of the document is reused, while the original content is replaced by its translated counterpart. Optionally, an addendum can be used to add some extra text to the translation. This is often used to add the name of the translator to the final document. See below for details.
it: La parte inferiore della figura mostra come L<po4a-translate(1)> crea un documento sorgente tradotto dal documento originale F<master.doc> e il catalogo di traduzioni F<doc.XX.po> aggiornato dai traduttori. La struttura del documento viene riutilizzata, mentre il contenuto originale viene sostituito dalla sua controparte tradotta. Facoltativamente, è possibile utilizzare un'appendice per aggiungere del testo extra alla traduzione. Viene spesso utilizzato per aggiungere il nome del traduttore al documento finale. Vedere sotto per i dettagli.

note: type: textblock
en: As noted before, the L<po4a(1)> program combines the effects of the separated scripts, updating the PO files and the translated document in one invocation.  The underlying logic remains the same.
it: Come notato prima, il programma L<po4a(1)> combina gli effetti degli script separati, aggiornando i file PO e il documento tradotto in un'unica esecuzione. La logica sottostante rimane la stessa.

note: type: =head2
en: Starting a new translation
it: Iniziare una nuova traduzione

note: type: textblock
en: If you use L<po4a(1)>, there is no specific step to start a translation. You just have to list the languages in the configuration file, and the missing PO files are automatically created. Naturally, the translator then have to provide translations for every content used in your documents. L<po4a(1)> also creates a POT file, that is a PO template file. Potential translators can translate your project into a new language by renaming this file and providing the translations in their language.
it: Se usa L<po4a(1)>, non esiste un passaggio specifico per avviare una traduzione. Bisogna solo elencare le lingue nel file di configurazione e i file PO mancanti verranno creati automaticamente. Naturalmente, il traduttore deve quindi fornire le traduzioni per ogni contenuto usato nei documenti. L<po4a(1)> crea anche un file POT, che è un file modello PO. I potenziali traduttori possono tradurre il progetto in una nuova lingua rinominando questo file e fornendo le traduzioni nella propria lingua.

note: type: textblock
en: If you prefer to use the individual scripts separately, you should use L<po4a-gettextize(1)> as follows to create the POT file. This file can then be copied into F<XX.po> to initiate a new translation.
it: Se preferisce usare i singoli script separatamente, bisognerebbe usare L<po4a-gettextize(1)> come segue per creare il file POT. Questo file potrà quindi essere copiato in F<XX.po> per iniziare una nuova traduzione.

note: type: verbatim
en:   $ po4a-gettextize --format <format> --master <master.doc> --po <translation.pot>
it:   $ po4a-gettextize --format <formato> --master <master.doc> --po <traduzione.pot>

note: type: textblock
en: The master document is used in input, while the POT file is the output of this process.
it: Il documento master viene utilizzato in ingresso, mentre il file POT è l'uscita di questo processo.

note: type: =head2
en: Integrating changes to the original document
it: Integrazione delle modifiche al documento originale

note: type: textblock
en: The script to use for that is L<po4a-updatepo(1)> (please refer to its documentation for details):
it: Lo script da usare per questo è L<po4a-updatepo(1)> (fare riferimento alla sua documentazione per i dettagli):

note: type: verbatim
en:   $ po4a-updatepo --format <format> --master <new_master.doc> --po <old_doc.XX.po>
it:   $ po4a-updatepo --format <formato> --master <nuovo_master.doc> --po <vecchio_doc.XX.po>

note: type: textblock
en: The master document is used in input, while the PO file is updated: it is used both in input and output.
it: Il documento master viene usato in ingresso, mentre il file PO viene aggiornato: viene utilizzato sia in ingresso che in uscita.

note: type: =head2
en: Generating a translated document
it: Generazione di un documento tradotto

note: type: textblock
en: Once you're done with the translation, you want to get the translated documentation and distribute it to users along with the original one.  For that, use the L<po4a-translate(1)> program as follows:
it: Una volta finito con la traduzione, si può voler prendere la documentazione tradotta e distribuirla agli utenti con quella originale.  A questo scopo, usare il programma L<po4a-translate(1)> in questo modo:

note: type: textblock
en: Both the master and PO files are used in input, while the localized file is the output of this process.
it: Sia il file master che PO vengono usati in ingresso, mentre il file localizzato (tradotto) è il file in uscita di questo processo.

note: type: =head2
en: Using addenda to add extra text to translations
it: Uso di addenda per aggiungere testo extra alle traduzioni

note: type: textblock
en: Adding new text to the translation is probably the only thing that is easier in the long run when you translate files manually :). This happens when you want to add an extra section to the translated document, not corresponding to any content in the original document. The classical use case is to give credits to the translation team, and to indicate how to report translation-specific issues.
it: L'aggiunta di nuovo testo alla traduzione è probabilmente l'unica cosa che è più facile fare a lungo termine quando si traducono i file manualmente :). Si fa quando si vuole aggiungere una sezione extra al documento tradotto che non corrisponde a nessun contenuto nel documento originale. Il caso d'uso classico è quello per dare riconoscimento ai traduttori e per indicare come segnalare problemi specifici riguardanti la traduzione.

note: type: textblock
en: With po4a, you have to specify B<addendum> files, that can be conceptually viewed as patches applied to the localized document after processing. Each addendum must be provided as a separate file, which format is however very different from the classical patches. The first line is a I<header line>, defining the insertion point of the addendum (with an unfortunately cryptic syntax -- see below) while the rest of the file is added verbatim at the determined position.
it: Con po4a, bisogna specificare i file B<addendum>, che possono essere visti concettualmente come patch applicate al documento localizzato dopo l'elaborazione. Ogni addendum deve essere fornito come file separato, il cui formato è però molto diverso dalle patch classiche. La prima riga è una I<riga di intestazione>, che definisce il punto di inserimento dell'addendum (con una sintassi purtroppo criptica - vedere sotto) mentre il resto del file viene aggiunto, così com'è, alla posizione determinata.

note: type: textblock
en: The header line must begin with the string B<PO4A-HEADER:>, followed by a semi-colon separated list of I<key>B<=>I<value> fields.
it: La riga di intestazione deve iniziare con la stringa B<PO4A-HEADER:>, seguita da un elenco separato da punti e virgola di campi I<chiave>B<=>I<valore>.

note: type: textblock
en: For example, the following header declares an addendum that must be placed at the very end of the translation.
it: Ad esempio, la seguente intestazione dichiara un addendum che deve essere inserito alla fine della traduzione.

note: type: textblock
en: Things are more complex when you want to add your extra content in the middle of the document. The following header declares an addendum that must be placed after the XML section containing the string C<About this document> in translation.
it: Le cose si fanno più complicate quando vuole aggiungere il contenuto extra in mezzo al documento. La seguente intestazione dichiara un addendum che deve essere inserito dopo la sezione XML contenente la stringa C<About this document> nella traduzione.

note: type: textblock
en: In practice, when trying to apply an addendum, po4a searches for the first line matching the C<position> argument (this can be a regexp). Do not forget that po4a considers the B<translated> document here. This documentation is in English, but your line should probably read as follows if you intend your addendum to apply to the French translation of the document.
it: In pratica, quando si cerca di applicare un addendum, po4a cerca la prima riga che corrisponde all'argomento C<position> (può essere un'espressione regolare). Non bisogna dimenticare che qui po4a considera il documento B<tradotto>. Questa documentazione è in inglese, ma la propria riga dovrebbe probabilmente essere la seguente, se si intende applicare l'addendum alla traduzione francese del documento.

note: type: textblock
en: Once the C<position> is found in the target document, po4a searches for the next line after the C<position> that matches the provided C<endboundary>. The addendum is added right B<after> that line (because we provided an I<endboundary>, i.e. a boundary ending the current section).
it: Una volta trovata la C<position> (posizione) nel documento di destinazione, po4a cerca la riga successiva dopo la C<position> che corrisponde al C<endboundary> fornito. L'addendum viene aggiunto subito B<after> (dopo) quella riga (perché abbiamo fornito una I<endboundary>, cioè un confine che termina la sezione corrente).

note: type: textblock
en: The exact same effect could be obtained with the following header, that is equivalent:
it: Lo stesso identico effetto potrebbe essere ottenuto con la seguente intestazione, che è equivalente:

note: type: textblock
en: Here, po4a searches for the first line matching C<<section>> after the line matching C<About this document> in the translation, and add the addendum B<before> that line since we provided a I<beginboundary>, i.e. a boundary marking the beginning of the next section. So this header line requires to place the addendum after the section containing C<About this document>, and instruct po4a that a section starts with a line containing the C<<section>> tag. This is equivalent to the previous example because what you really want is to add this addendum either after C</section>> or before C<<section>>.
it: Qui, po4a cerca la prima riga che corrisponde a C<<section>> dopo la riga che corrisponde a C<About this document> nella traduzione e aggiunge l'addendum B<before> (prima) quella riga poiché abbiamo fornito un I<beginboundary>, cioè un confine che segna l'inizio della sezione successiva. Quindi questa riga di intestazione richiede di inserire l'addendum dopo la sezione contenente C<About this document> e istruire po4a che una sezione inizia con una riga contenente il tag C<<section>>. Questo è equivalente all'esempio precedente perché quello che si vuole veramente è aggiungere questo addendum dopo C</section>> o prima di C<<section>>.

note: type: textblock
en: You can also set the insertion I<mode> to the value C<before>, with a similar semantic: combining C<mode=before> with an C<endboundary> will put the addendum just B<after> the matched boundary, that the last potential boundary line before the C<position>. Combining C<mode=before> with an C<beginboundary> will put the addendum just B<before> the matched boundary, that the last potential boundary line before the C<position>.
it: Si può anche impostare l'inserimento I<mode> al valore C<before>, con una semantica simile: combinando C<mode=before> con C<endboundary> metterà l'addendum appena B<dopo> il limite corrispondente, l'ultima potenziale linea di confine prima della C<position>. La combinazione di C<mode=before> e C<beginboundary> metterà l'addendum appena B<prima> del confine corrispondente, ovvero l'ultima potenziale linea di confine prima di C<position>.

note: type: verbatim
en:   Mode   | Boundary kind |     Used boundary      | Insertion point compared to the boundary
     ========|===============|========================|=========================================
     'before'| 'endboundary' | last before 'position' | Right after the selected boundary
     'before'|'beginboundary'| last before 'position' | Right before the selected boundary
     'after' | 'endboundary' | first after 'position' | Right after the selected boundary
     'after' |'beginboundary'| first after 'position' | Right before the selected boundary
     'eof'   |   (none)      |  n/a                   | End of file
it:   Modo   | Tipo confine  |     Confine usato       | Punto di inserimento rispetto al confine
     ========|===============|=========================|=========================================
     'before'| 'endboundary' | ultimo prima 'position' | Subito dopo del confine selezionato
     'before'|'beginboundary'| ultimo prima 'position' | Subito prima del confine selezionato
     'after' | 'endboundary' |  primo dopo 'position'  | Subito dopo del confine selezionato
     'after' |'beginboundary'|  primo dopo 'position'  | Subito prima del confine selezionato
     'eof'   |   (nessuno)   |           -             | Fine del file

note: type: =head3
en: Hint and tricks about addenda
it: Suggerimenti e trucchi sugli addenda

note: type: textblock
en: Remember that these are regexp. For example, if you want to match the end of a nroff section ending with the line C<.fi>, do not use C<.fi> as B<endboundary>, because it will match with C<the[ fi]le>, which is obviously not what you expect. The correct B<endboundary> in that case is: C<^\.fi$>.
it: Si ricordi che queste sono espressioni regolari. Per esempio, se si vuole far corrispondere la fine di una sezione nroff con la riga C<.fi>, non usare C<.fi> come B<endboundary>, perché corrisponderebbe con C<il[ fi]le>, che ovviamente non è quello che ci si aspettava. Il corretto B<endboundary> in tal caso è: C<^\.fi$>.

note: type: textblock
en: White spaces ARE important in the content of the C<position> and boundaries. So the two following lines B<are different>. The second one will only be found if there is enough trailing spaces in the translated document.
it: Gli spazi bianchi SONO importanti nel contenuto di C<position> e dei confini. Quindi le due righe seguenti B<sono diverse>. Il secondo verrà trovato solo se ci sono abbastanza spazi finali nel documento tradotto.

note: type: textblock
en: Although this context search may be considered to operate roughly on each line of the B<translated> document, it actually operates on the internal data string of the translated document. This internal data string may be a text spanning a paragraph containing multiple lines or may be a XML tag itself alone. The exact I<insertion point> of the addendum must be before or after the internal data string and can not be within the internal data string.
it: Sebbene questa ricerca di contesto possa essere considerata come operante approssimativamente su ciascuna riga del documento B<tradotto>, in realtà opera sulla stringa dati interna del documento tradotto. Questa stringa dati interna può essere un testo che si estende su un paragrafo contenente più righe o può essere la marcatura XML stessa da sola. L'esatto I<punto di inserimento> dell'addendum deve essere prima o dopo la stringa dati interna e non può essere all'interno della stessa.

note: type: textblock
en: Pass the B<-vv> argument to po4a to understand how the addenda are added to the translation. It may also help to run po4a in debug mode to see the actual internal data string when your addendum does not apply.
it: Passa l'argomento B<-vv> a po4a per capire come aggiungere gli addenda alla traduzione. Può anche essere utile eseguire po4a in modalità di debug per vedere la stringa di dati interna effettiva quando l'addendum non si applica.

note: type: =head3
en: Addenda examples
it: Esempi di addenda

note: type: textblock
en: If you want to add something after the following nroff section:
it: Se si vuole aggiungere qualcosa dopo la seguente sezione nroff:

note: type: textblock
en: You should select a two step approach by setting B<mode=after>. Then you should narrow down search to the line after B<AUTHORS> with the B<position> argument regex. Then, you should match the beginning of the next section (i.e., B<^\.SH>) with the B<beginboundary> argument regex. That is to say:
it: È necessario selezionare un approccio in due fasi impostando B<mode=after>. Quindi bisogna restringere la ricerca alla riga dopo B<AUTHORS> con l'argomento espressione regolare B<position>. Quindi, si dovrebbe abbinare l'inizio della sezione successiva (ad esempio, B<^\.SH>) con l'espressione regolare dell'argomento B<beginboundary>. Vale a dire:

note: type: textblock
en: If you want to add something right after a given line (e.g. after the line "Copyright Big Dude"), use a B<position> matching this line, B<mode=after> and give a B<beginboundary> matching any line.
it: Se si vuole aggiungere qualcosa dopo una data riga (come dopo "Copyright Big Dude"), fare in modo che B<position> corrisponda a questa riga, B<mode=after> e fare in modo che B<beginboundary> corrisponda a qualunque riga.

note: type: textblock
en: If you want to add something at the end of the document, give a B<position> matching any line of your document (but only one line. Po4a won't proceed if it's not unique), and give an B<endboundary> matching nothing. Don't use simple strings here like B<"EOF">, but prefer those which have less chance to be in your document.
it: Se si vuole aggiungere qualcosa alla fine del documento, fare in modo che B<position> corrisponda a qualunque riga del documento (ma solo una riga. Po4a non procederà se questa non è univoca), e fare in modo che B<endboundary> non corrisponda a nulla. Non usare stringhe semplici come B<"EOF">, ma preferire quelle che hanno meno probabilità di esistere nel documento.

note: type: =head3
en: More detailed example
it: Esempio più dettagliato

note: type: textblock
en: Original document (POD formatted):
it: Documento originale (formattato POD):

note: type: verbatim
en:  |=head1 NAME
     |
     |dummy - a dummy program
     |
     |=head1 AUTHOR
     |
     |me
it:  |=head1 NOME
     |
     |dummy - un programma fantoccio
     |
     |=head1 AUTORE
     |
     |me

note: type: textblock
en: Then, the following addendum will ensure that a section (in French) about the translator is added at the end of the file (in French, "TRADUCTEUR" means "TRANSLATOR", and "moi" means "me").
it: Poi, il seguente addendum assicurerà che una sezione (in Francese) riguardante il traduttore venga aggiunta alla fine del file (in Francese, "TRADUCTEUR" significa "TRADUTTORE", e "moi" significa "me").

note: type: textblock
en: To put your addendum before the AUTHOR, use the following header:
it: Per mettere il proprio addendum prima dell'AUTHOR, usare l'intestazione seguente:

note: type: textblock
en: This works because the next line matching the B<beginboundary> /^=head1/ after the section "NAME" (translated to "NOM" in French), is the one declaring the authors. So, the addendum will be put between both sections. Note that if another section is added between NAME and AUTHOR sections later, po4a will wrongfully put the addenda before the new section.
it: Questo funziona perché la successiva riga che corrisponde al B<beginboundary> /^=head1/ dopo la sezione "NAME" (tradotta in "NOM" in Francese), è quella che dichiara gli autori. Perciò, l'addendum verrà messo tra entrambe le sezioni. Si noti che se un'altra sezione viene aggiunta in seguito tra le sezioni NAME e AUTHOR, po4a metterà erroneamente l'addenda prima della nuova sezione.

note: type: textblock
en: To avoid this you may accomplish the same using B<mode>=I<before>:
it: Per evitare ciò si può ottenere lo stesso risultato usando B<mode>=I<before>:

note: type: =head1
en: How does it work?
it: Come funziona?

note: type: textblock
en: This chapter gives you a brief overview of the po4a internals, so that you may feel more confident to help us maintaining and improving it. It may also help you understanding why it does not do what you expected, and how to solve your problems.
it: Questo capitolo fornisce una breve panoramica del funzionamento interno di po4a, in modo che vi possiate sentire a vostro agio se desiderate aiutarci nella manutenzione e contribuire al miglioramento di questo software. Il capitolo può anche aiutare a capire perché il programma non si comporta come ci si aspetta e a risolvere eventuali problemi.

note: type: textblock
en: The po4a architecture is object oriented. The L<Locale::Po4a::TransTractor(3pm)|TransTractor> class is the common ancestor to all po4a parsers. This strange name comes from the fact that it is at the same time in charge of translating document and extracting strings.
it: L'architettura po4a è object oriented. La classe L<Locale::Po4a::TransTractor(3pm)|TransTractor> è l'antenato comune di tutte le classi parser. Questo strano nome deriva dal fatto che è allo stesso tempo incaricato di tradurre il documento e di estrarne le stringhe.

note: type: textblock
en: More formally, it takes a document to translate plus a PO file containing the translations to use as input while producing two separate outputs: Another PO file (resulting of the extraction of translatable strings from the input document), and a translated document (with the same structure than the input one, but with all translatable strings replaced with content of the input PO). Here is a graphical representation of this:
it: Più formalmente, esso prende un documento da tradurre più un file PO contenente le traduzioni da usare come ingresso producendo due risultati separati: un altro file PO (risultato dall'estrazione delle stringhe traducibili dal documento in ingresso), e un documento tradotto (con la stessa struttura di quello in ingresso, ma con tutte le stringhe traducibili rimpiazzate dal contenuto del file PO in ingresso). Ecco una rappresentazione grafica di tutto ciò:

note: type: verbatim
en:    Input document --\                             /---> Output document
                         \      TransTractor::       /       (translated)
                          +-->--   parse()  --------+
                         /                           \
       Input PO --------/                             \---> Output PO
                                                             (extracted)
it:    Documento in ingresso --\                             /---> Documento in uscita
                                \      TransTractor::       /      (tradotto)
                                +-->--   parse()  --------+
                                /                           \
       PO in ingresso ---------/                             \---> PO in uscita
                                                                   (estratto)

note: type: textblock
en: This little bone is the core of all the po4a architecture. If you omit the input PO and the output document, you get B<po4a-gettextize>. If you provide both input and disregard the output PO, you get B<po4a-translate>. The B<po4a> calls TransTractor twice and calls B<msgmerge -U> between these TransTractor invocations to provide one-stop solution with a single configuration file.  Please see L<Locale::Po4a::TransTractor(3pm)> for more details.
it: Questo piccolo osso è il cuore di tutta l'architettura di po4a. Se si omette il file PO in ingresso e il documento in uscita, si ottiene B<po4a-gettextize>. Se si fornisce entrambi gli ingressi e si ignora il file PO in uscita, si ottiene B<po4a-translate>. B<po4a> chiama TransTractor due volte e chiama B<msgmerge -U> tra queste invocazioni di TransTractor per fornire una soluzione tutta in uno con un singolo file di configurazione. Vedere L<Locale::Po4a::TransTractor(3pm)> per ulteriori dettagli."

note: type: =head1
en: Open-source projects using po4a
it: Progetti open source che usano po4a

note: type: textblock
en: Here is a very partial list of projects that use po4a in production for their documentation. If you want to add your project to the list, just drop us an email (or a Merge Request).
it: Ecco un elenco molto incompleto di progetti che usano po4a in produzione per la loro documentazione. Se si vuole aggiungere il proprio progetto all'elenco, inviaci un'e-mail (o una richiesta di merge).

note: type: textblock
en: adduser (man): users and groups management tool.
it: adduser (man): strumento di gestione utenti e gruppi.

note: type: textblock
en: apt (man, docbook): Debian package manager.
it: apt (man, docbook): gestore pacchetti Debian.

note: type: textblock
en: aptitude (docbook, svg): terminal-based package manager for Debian
it: aptitude (docbook, svg): gestore pacchetti basato sul terminale per Debian.

note: type: textblock
en: L<F-Droid website|https://gitlab.com/fdroid/fdroid-website> (markdown): installable catalogue of FOSS (Free and Open Source Software) applications for the Android platform.
it: L<Sito web F-Droid|https://gitlab.com/fdroid/fdroid-website> (markdown): catalogo installabile di applicazioni FOSS (Free and Open Source Software) per la piattaforma Android.

note: type: textblock
en: L<git|https://github.com/jnavila/git-manpages-l10n> (asciidoc): distributed version-control system for tracking changes in source code.
it: L<git|https://github.com/jnavila/git-manpages-l10n> (asciidoc): sistema di controllo versione distribuito per tenere traccia delle modifiche nel codice sorgente.

note: type: textblock
en: L<Linux manpages|https://salsa.debian.org/manpages-l10n-team/manpages-l10n> (man)
it: L<Pagine man di Linux|https://salsa.debian.org/manpages-l10n-team/manpages-l10n> (man)

note: type: textblock
en: This project provides an infrastructure for translating many manpages to different languages, ready for integration into several major distributions (Arch Linux, Debian and derivatives, Fedora).
it: Questo progetto fornisce un'infrastruttura per la traduzione delle pagine man in diverse lingue, pronta per l'integrazione nelle principali distribuzioni (Arch Linux, Debian e derivate, Fedora, ecc.).

note: type: textblock
en: L<Stellarium|https://github.com/Stellarium/stellarium> (HTML): a free open source planetarium for your computer. po4a is used to translate the sky culture descriptions.
it: L<Stellarium|https://github.com/Stellarium/stellarium> (HTML): un planetario libero e open source per il proprio computer. po4a viene usato per tradurre le descrizioni nelle varie culture del cielo.

note: type: textblock
en: Other item to sort out: L<https://gitlab.com/fdroid/fdroid-website/> L<https://github.com/fsfe/reuse-docs/pull/61>
it: Altro elemento da sistemare: L<https://gitlab.com/fdroid/fdroid-website/> L<https://github.com/fsfe/reuse-docs/pull/61>

note: type: =head2
en: How do you pronounce po4a?
it: Come si pronuncia po4a?

note: type: textblock
en: I personally vocalize it as L<pouah|https://en.wiktionary.org/wiki/pouah>, which is a French onomatopoetic that we use in place of yuck :) I may have a strange sense of humor :)
it: Personalmente lo pronuncio come L<pouah|https://en.wiktionary.org/wiki/pouah>, che è un termine onomatopeico francese che si usa al posto di puah :) forse ho uno strano senso dell'umorismo :)

note: type: =head2
en: What about the other translation tools for documentation using gettext?
it: E gli altri strumenti di traduzione per la documentazione che usano gettext?

note: type: textblock
en: There are a few of them. Here is a possibly incomplete list, and more tools are coming at the horizon.
it: Ce ne sono alcuni. Ecco un elenco forse incompleto e altri strumenti stanno arrivando all'orizzonte.

note: type: textblock
en: This is the tool developed by KDE people to handle DocBook XML. AFAIK, it was the first program to extract strings to translate from documentation to PO files, and inject them back after translation.
it: Questo è lo strumento sviluppato dalle persone del progetto KDE per gestire DocBook XML. Per quanto ne sappiamo, è stato il primo programma a estrarre le stringhe da tradurre dalla documentazione in file PO e ad iniettarle nuovamente dopo la traduzione.

note: type: textblock
en: It can only handle XML, and only a particular DTD. I'm quite unhappy with the handling of lists, which end in one big msgid. When the list become big, the chunk becomes harder to swallow.
it: Può gestire solo XML e solo una particolare DTD. Non piace particolarmente la gestione degli elenchi, che finiscono in un unico grande msgid. Quando l'elenco diventa grande, il blocco diventa più difficile da gestire.

note: type: textblock
en: This program done by Denis Barbier is a sort of precursor of the po4a SGML module, which more or less deprecates it. As the name says, it handles only the DebianDoc DTD, which is more or less a deprecated DTD.
it: Questo programma realizzato da Denis Barbier è una sorta di precursore del modulo SGML po4a, che più o meno lo rende deprecato. Come dice il nome, gestisce solo la DTD DebianDoc, che è più o meno una DTD deprecata.

note: type: textblock
en: Used by the GIMP Documentation Team since 2004, works quite well even if, as the name suggests, only with XML files and needs specially configured makefiles.
it: Utilizzato dal Gruppo di Documentazione di GIMP dal 2004, funziona abbastanza bene anche se, come suggerisce il nome, solo con file XML e necessita di makefile appositamente configurati.

note: type: textblock
en: The Sphinx Documentation Project also uses gettext extensively to manage its translations. Unfortunately, it works only for a few text formats, rest and markdown, although it is perhaps the only tool that does this managing the whole translation process.
it: Il Progetto Sphinx usa anch'esso ampiamente gettext per gestire le traduzioni. Sfortunatamente, funziona solo per pochi formati di testo, rest e markdown, anche se forse è l'unico strumento che fa questo gestendo l'intero processo di traduzione.

note: type: textblock
en: The main advantages of po4a over them are the ease of extra content addition (which is even worse there) and the ability to achieve gettextization.
it: I principali vantaggi di po4a rispetto ad essi sono la facilità di aggiunta di contenuti extra (che è anche più arduo) e la capacità di ottenere la gettext-izzazione.

note: type: =head2
en: SUMMARY of the advantages of the gettext based approach
it: SOMMARIO dei vantaggi dell'approccio basato su gettext

note: type: textblock
en: The translations are not stored along with the original, which makes it possible to detect if translations become out of date.
it: Le traduzioni non vengono memorizzate insieme all'originale, il che rende possibile rilevare se le traduzioni diventano obsolete.

note: type: textblock
en: The translations are stored in separate files from each other, which prevents translators of different languages from interfering, both when submitting their patch and at the file encoding level.
it: Le traduzioni vengono memorizzate in file separati l'uno dall'altro, il che impedisce ai traduttori di lingue diverse di interferire, sia quando inviano la loro patch che a livello di codifica del file.

note: type: textblock
en: It is based internally on B<gettext> (but B<po4a> offers a very simple interface so that you don't need to understand the internals to use it).  That way, we don't have to re-implement the wheel, and because of their wide use, we can think that these tools are more or less bug free.
it: È basato internamente su B<gettext> (ma B<po4a> offre un'interfaccia molto semplice in modo che non sia necessario comprendere le parti interne per usarlo). In questo modo, non bisogna reinventare la ruota e, a causa del loro ampio utilizzo, possiamo assumere che questi strumenti siano più o meno privi di bug.

note: type: textblock
en: Nothing changed for the end-user (beside the fact translations will hopefully be better maintained). The resulting documentation file distributed is exactly the same.
it: Non cambia nulla per l'utente finale (a parte il fatto che si spera che le traduzioni vengano mantenute meglio). Il file di documentazione risultante distribuito rimane esattamente lo stesso.

note: type: textblock
en: No need for translators to learn a new file syntax and their favorite PO file editor (like Emacs' PO mode, Lokalize or Gtranslator) will work just fine.
it: Non c'è bisogno che i traduttori imparino una nuova sintassi di file e il loro editor di file PO preferito (come la modalità PO di Emacs, Lokalize o Gtranslator) funzionerà perfettamente.

note: type: textblock
en: gettext offers a simple way to get statistics about what is done, what should be reviewed and updated, and what is still to do. Some example can be found at those addresses:
it: gettext offre un modo semplice per ottenere statistiche su ciò che è stato fatto, cosa dovrebbe essere revisionato e aggiornato, e cosa c'è ancora da fare. Qualche esempio si può trovare su:

note: type: textblock
en: But everything isn't green, and this approach also has some disadvantages we have to deal with.
it: Ma non è tutto rose e fiori e questo approccio presenta anche alcuni svantaggi che dobbiamo affrontare.

note: type: textblock
en: Addenda are… strange at the first glance.
it: Gli addenda sono… strani ad una prima occhiata.

note: type: textblock
en: You can't adapt the translated text to your preferences, like splitting a paragraph here, and joining two other ones there. But in some sense, if there is an issue with the original, it should be reported as a bug anyway.
it: Non si può adattare il testo tradotto alle proprie preferenze, come dividere un paragrafo qui e unirne altri due la. Ma in un certo senso è un bene, perché se c'è un problema con l'originale, dovrebbe comunque essere segnalato come un bug all'autore.

note: type: textblock
en: Even with an easy interface, it remains a new tool people have to learn.
it: Anche con un'interfaccia semplice, rimane un nuovo strumento che le persone devono imparare.

note: type: textblock
en: One of my dreams would be to integrate somehow po4a to Gtranslator or Lokalize. When a documentation file is opened, the strings are automatically extracted, and a translated file + po file can be written to disk. If we manage to do an MS Word (TM) module (or at least RTF) professional translators may even use it.
it: Uno dei miei sogni sarebbe quello di integrare in qualche modo po4a in Gtranslator o Lokalize. Aprendo un file di documentazione, le stringhe potrebbero essere estratte automaticamente e file tradotto e file po potrebbe venire scritti su disco. Se si riesce a fare un modulo MS Word (TM) (o almeno RTF) persino i traduttori professionisti potrebbero usarlo.

note: type: textblock
en: The documentation of the all-in-one tool that you should use: L<po4a(1)>.
it: La documentazione dello strumento tutto-in-uno che si dovrebbe usare: L<po4a(1)>.

note: type: textblock
en: The documentation of the individual po4a scripts: L<po4a-gettextize(1)>, L<po4a-updatepo(1)>, L<po4a-translate(1)>, L<po4a-normalize(1)>.
it: La documentazione dei singoli script po4a: L<po4a-gettextize(1)>, L<po4a-updatepo(1)>, L<po4a-translate(1)>, L<po4a-normalize(1)>.

note: type: textblock
en: The additional helping scripts: L<msguntypot(1)>, L<po4a-display-man(1)>, L<po4a-display-pod(1)>.
it: Gli script di aiuto aggiuntivi: L<msguntypot(1)>, L<po4a-display-man(1)>, L<po4a-display-pod(1)>.

note: type: textblock
en: The parsers of each formats, in particular to see the options accepted by each of them: L<Locale::Po4a::AsciiDoc(3pm)> L<Locale::Po4a::Dia(3pm)>, L<Locale::Po4a::Guide(3pm)>, L<Locale::Po4a::Ini(3pm)>, L<Locale::Po4a::KernelHelp(3pm)>, L<Locale::Po4a::Man(3pm)>, L<Locale::Po4a::RubyDoc(3pm)>, L<Locale::Po4a::Texinfo(3pm)>, L<Locale::Po4a::Text(3pm)>, L<Locale::Po4a::Xhtml(3pm)>, L<Locale::Po4a::Yaml(3pm)>, L<Locale::Po4a::BibTeX(3pm)>, L<Locale::Po4a::Docbook(3pm)>, L<Locale::Po4a::Halibut(3pm)>, L<Locale::Po4a::LaTeX(3pm)>, L<Locale::Po4a::Pod(3pm)>, L<Locale::Po4a::Sgml(3pm)>, L<Locale::Po4a::TeX(3pm)>, L<Locale::Po4a::Wml(3pm)>, L<Locale::Po4a::Xml(3pm)>.
it: I parser di ogni formato, in particolare per vedere le opzioni accettate da ognuno di essi: L<Locale::Po4a::AsciiDoc(3pm)> L<Locale::Po4a::Dia(3pm)>, L<Locale::Po4a::Guide(3pm)>, L<Locale::Po4a::Ini(3pm)>, L<Locale::Po4a::KernelHelp(3pm)>, L<Locale::Po4a::Man(3pm)>, L<Locale::Po4a::RubyDoc(3pm)>, L<Locale::Po4a::Texinfo(3pm)>, L<Locale::Po4a::Text(3pm)>, L<Locale::Po4a::Xhtml(3pm)>, L<Locale::Po4a::Yaml(3pm)>, L<Locale::Po4a::BibTeX(3pm)>, L<Locale::Po4a::Docbook(3pm)>, L<Locale::Po4a::Halibut(3pm)>, L<Locale::Po4a::LaTeX(3pm)>, L<Locale::Po4a::Pod(3pm)>, L<Locale::Po4a::Sgml(3pm)>, L<Locale::Po4a::TeX(3pm)>, L<Locale::Po4a::Wml(3pm)>, L<Locale::Po4a::Xml(3pm)>.

note: type: textblock
en: The implementation of the core infrastructure: L<Locale::Po4a::TransTractor(3pm)> (particularly important to understand the code organization), L<Locale::Po4a::Chooser(3pm)>, L<Locale::Po4a::Po(3pm)>, L<Locale::Po4a::Common(3pm)>. Please also check the F<CONTRIBUTING.md> file in the source tree.
it: L'implementazione del nucleo della struttura: L<Locale::Po4a::TransTractor(3pm)> (particularly important to understand the code organization), L<Locale::Po4a::Chooser(3pm)>, L<Locale::Po4a::Po(3pm)>, L<Locale::Po4a::Common(3pm)>. Controllare anche il file F<CONTRIBUTING.md> nell'albero dei sorgenti.

note: type: textblock
en: Locale::Po4a::AsciiDoc - convert AsciiDoc documents from/to PO files
it: Locale::Po4a::AsciiDoc - converte documenti AsciiDoc da/a file PO

note: type: textblock
en: Locale::Po4a::AsciiDoc is a module to help the translation of documentation in the AsciiDoc format.
it: Locale::Po4a::AsciiDoc è un modulo che serve ad aiutare la traduzione di documentazione nel formato AsciiDoc.

note: type: =head1
en: OPTIONS ACCEPTED BY THIS MODULE
it: OPZIONI ACCETTATE DA QUESTO MODULO

note: type: textblock
en: These are this module's particular options:
it: Queste sono le opzioni speciali per questo modulo:

note: type: textblock
en: The name of a file containing definitions for po4a, as defined in the B<INLINE CUSTOMIZATION> section.  You can use this option if it is not possible to put the definitions in the document being translated.
it: Il nome del file contenente le definizioni per po4a, come definito nella sezione B<PERSONALIZZAZIONE INLINE>.  Si può usare questa opzione se non è possibile mettere le definizioni nel documento che si sta traducendo.

note: type: textblock
en: In a definitions file, lines must not start by two slashes, but directly by B<po4a:>.
it: Nel file delle definizioni, le righe non devono cominciare con due caratteri di slash, ma direttamente con B<po4a:>.

note: type: textblock
en: Space-separated list of attribute entries you want to translate.  By default, no attribute entries are translatable.
it: Elenco separato da spazi di voci di attributi che si desidera tradurre. Come impostaione predefinita, nessuna voce di attributo è traducibile.

note: type: textblock
en: Space-separated list of macro definitions.
it: Elenco separato da spazi di definizioni di macro.

note: type: textblock
en: Space-separated list of style definitions.
it: Elenco separato da spazi di definizioni di stile.

note: type: textblock
en: Enable automatic line wrapping in non-verbatim blocks, even if the result could be misinterpreted by AsciiDoc formatters.
it: Abilita il ritorno a capo automatico nei blocchi non-verbatim, anche se il risultato potrebbe essere mal interpretato dai compilatori AsciiDoc.

note: type: textblock
en: By default, po4a will not wrap the produced AsciiDoc files because a manual inspection is mandated to ensure that the wrapping does not change the formatting. Consider for instance the following list item:
it: Per impostazione predefinita, po4a non manderà a capo i file AsciiDoc prodotti perché ciò rende necessaria un'ispezione manuale per controllare che ciò non cambi la formattazione. Si consideri per esempio il seguente elenco puntato:

note: type: verbatim
en:  * a long sentence that is ending with a number 1. A second sentence.
it:  * una lunga frase che finisce con un numero 1. Una seconda frase.

note: type: textblock
en: If the wrapping leads to the following presentation, the item is split into a numbered sub-list. To make things worse, only the speakers of the language used in the translation can inspect the situation.
it: Se l'andare a capo porta alla seguente rappresentazione, l'elenco viene spezzato in un sotto elenco numerato. A peggiorare le cose, solo i parlanti della lingua usata nella traduzione possono controllare la situazione.

note: type: verbatim
en:  * a long sentence that is ending with a number
       1. A second sentence.
it:  * una lunga frase che finisce con un numero
       1. Una seconda frase.

note: type: textblock
en: Note that not wrapping the files produced by po4a should not be a problem since those files are meant to be processed automatically.  They should not be regarded as source files anyway.
it: Si noti che il non andare a capo dei file prodotti da po4a non dovrebbe essere un problema dato che questi file sono stati fatti per essere elaborati automaticamente.  Non dovrebbero comunque essere considerati come file sorgenti.

note: type: textblock
en: With this option, po4a will produce better-looking source files, that may lead to possibly erroneous formatted outputs.
it: Con questa opzione, po4a produrrà file sorgenti più esteticamente belli, ma che possono portare a risultati formattati erroneamente.

note: type: textblock
en: By default, the targets of block images are translatable to give opportunity to make the content point to translated images. This can be stopped by setting this option.
it: Per impostazione predefinita, gli obiettivi dei blocchi immagini sono traducibili, ciò per fare in modo che il contenuto punti a immagini tradotte. Questo comportamento può essere evitato impostando questa opzione.

note: type: textblock
en: This option is a flag that enables sub-table segmentation into cell content.  The segmentation is limited to cell content, without any parsing inside of it.
it: Questa opzione abilita la segmentazione delle subtabelle in contenuto cella.  La segmentazione è limitata al contenuto della cella, senza analisi dell'interno di essa.

note: type: textblock
en: Switch parsing rules to compatibility with different tools. Available options are "asciidoc" or "asciidoctor". Asciidoctor has stricter parsing rules, such as equality of length of opening and closing block fences.
it: Commuta le regole di analisi alla compatibilità con diversi strumenti. Le opzioni disponibili sono "asciidoc" o "asciidoctor". Asciidoctor ha delle regole più stringenti, come uguale lunghezza dei marcatori di apertura e chiusura blocchi.

note: type: textblock
en: Disable linting messages. When the source code cannot be fixed for clearer document structure, these messages are useless.
it: Disabilita i messaggi di linting. Quando il codice sorgente non può essere sistemato per mantenere una struttura documentale più chiara, questi messaggi sono inutili.

note: type: textblock
en: Comma-separated list of keys to process for translation in the YAML Front Matter section. All other keys are skipped. Keys are matched with a case-sensitive match. If B<yfm_paths> and B<yfm_keys> are used together, values are included if they are matched by at least one of the options. Array values are always translated, unless the B<yfm_skip_array> option is provided.
it: Elenco di chiavi separate da virgole da elaborare per la traduzione nella sezione Front Matter YAML. Tutte le altre chiavi vengono saltate. Le chiavi vengono confrontate distinguendo tra maiuscole e minuscole. Se B<yfm_paths> e B<yfm_keys> vengono utilizzati insieme, i valori vengono inclusi se corrispondono ad almeno una delle opzioni. I valori dell'array vengono sempre tradotti, a meno che non venga fornita l'opzione B<yfm_skip_array>.

note: type: textblock
en: Do not translate array values in the YAML Front Matter section.
it: Indica di non tradurre il valori array nella sezione Front Matter di YAML.

note: type: textblock
en: Comma-separated list of hash paths to process for extraction in the YAML Front Matter section, all other paths are skipped. Paths are matched with a case-sensitive match. If B<yfm_paths> and B<yfm_keys> are used together, values are included if they are matched by at least one of the options.  Arrays values are always returned unless the B<yfm_skip_array> option is provided.
it: Elenco separato da virgole di percorsi hash da elaborare per l'estrazione nella sezione Front Matter YAML, tutti gli altri percorsi vengono ignorati. I percorsi vengono confrontati con distinzione tra maiuscole e minuscole. Se B<yfm_paths> e B<yfm_keys> vengono utilizzati insieme, i valori vengono inclusi se corrispondono ad almeno una delle opzioni. I valori degli array vengono sempre restituiti a meno che non venga fornita l'opzione B<yfm_skip_array>.

note: type: =head1
en: INLINE CUSTOMIZATION
it: PERSONALIZZAZIONE INLINE

note: type: textblock
en: The AsciiDoc module can be customized with lines starting by B<//po4a:>.  These lines are interpreted as commands to the parser.  The following commands are recognized:
it: Il modulo AsciiDoc può essere personalizzato con righe che cominciano con B<//po4a:>.  Queste righe vengono interpretate come comandi dal parser.  Sono riconosciuti i seguenti comandi:

note: type: =item
en: B<//po4a: macro >I<name>B<[>I<attribute list>B<]>
it: B<//po4a: macro >I<nome>B<[>I<elenco attributi>B<]>

note: type: textblock
en: This describes in detail the parameters of a B<macro>; I<name> must be a valid macro name, and it ends with an underscore if the target must be translated.
it: Questo descrive in dettaglio i parametri di una B<macro>; I<nome> deve essere un nome macro valido, e finisce con un carattere di sottolineatura (underscore) se l'obiettivo va tradotto.

note: type: textblock
en: The I<attribute list> argument is a comma separated list which contains information about translatable arguments.  This list contains either numbers, to define positional parameters, or named attributes.
it: L'argomento I<elenco attributi> è un elenco separato da virgole che contiene informazioni sugli argomenti traducibili.  Questo elenco contiene numeri, per definire parametri posizionali, o attributi con nome.

note: type: textblock
en: If a plus sign (B<+>) is prepended to I<name>, then the macro and its arguments are translated as a whole.  There is no need to define attribute list in this case, but brackets must be present.
it: Se un segno più (B<+>) viene preposto a I<nome>, allora la macro ed i suoi argomenti vengono tradotti come un tutt'uno.  In questo caso non è necessaria la definizione dell'elenco attributi, ma le parentesi (quadre) devono essere presenti.

note: type: =item
en: B<//po4a: style >B<[>I<attribute list>B<]>
it: B<//po4a: stile >B<[>I<elenco attributi>B<]>

note: type: textblock
en: This describes in detail which attributes of a style must be translated.
it: Questo descrivere in dettaglio quali attributi di uno stile devono essere tradotti.

note: type: textblock
en: The I<attribute list> argument is a comma separated list which contains information about translatable arguments.  This list contains either numbers, to define positional parameters, or named attributes.  The first attribute is the style name, it will not be translated.
it: L'argomento I<elenco attributi> è un elenco separato da virgole che contiene informazioni sugli argomenti traducibili.  Questo elenco contiene numeri, per definire parametri posizionali, o attributi con nome.  Il primo attributo, il nome dello stile, non verrà tradotto.

note: type: textblock
en: If a plus sign (B<+>) is prepended to the style name, then the attribute list is translated as a whole.  There is no need to define translatable attributes.
it: Se un segno più (B<+>) viene preposto al nome dello stile, allora l'elenco attributi viene tradotto tutto insieme.  Non c'è necessità di definire attributi traducibili.

note: type: textblock
en: If a minus sign (B<->) is prepended to the style name, then this attribute is not translated.
it: Se un segno meno (B<->) viene preposto al nome dello stile, allora questo attributo non viene tradotto.

note: type: =item
en: B<//po4a: entry >I<name>
it: B<//po4a: voce >I<nome>

note: type: textblock
en: This declares an attribute entry as being translatable.  By default, they are not translated.
it: Questo dichiara una voce attributo come traducibile.  Per impostazione predefinita, non vengono tradotte.

note: type: =head1
en: STATUS OF THIS MODULE
it: STATO DI QUESTO MODULO

note: type: textblock
en: Tested successfully on simple AsciiDoc files.
it: Testato con successo su semplici file AsciiDoc.

note: type: verbatim
en:  Copyright © 2005-2008 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
     Copyright © 2012 Denis BARBIER <barbier@linuxfr.org>.
     Copyright © 2017 Martin Quinson <mquinson#debian.org>.
it:  Copyright © 2005-2008 by Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
     Copyright © 2012 by Denis BARBIER <barbier@linuxfr.org>.
     Copyright © 2017 by Martin Quinson <mquinson#debian.org>.

note: type: textblock
en: Locale::Po4a::BibTeX - convert BibTeX documents from/to PO files
it: Locale::Po4a::BibTeX - converte documenti BibTeX da/a file PO

note: type: textblock
en: Locale::Po4a::BibTeX is a module to help the translation of bibliographies in the BibTeX format into other [human] languages.
it: Locale::Po4a::BibTex è un modulo che aiuta la traduzione in altre lingue di bibliografie nel formato BibTex.

note: type: textblock
en: Fields values are extracted and proposed for translation.
it: I campi valore vengono estratti e proposti per la traduzione.

note: type: textblock
en: NONE.
it: NESSUNA.

note: type: textblock
en: It is a very simple module, but still young.
it: È un modulo molto semplice e ancora giovane.

note: type: verbatim
en:  Copyright © 2006 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
it:  Copyright © 2006 by Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.

note: type: textblock
en: Locale::Po4a::Chooser - manage po4a modules
it: Locale::Po4a::Chooser - gestisce i moduli di po4a

note: type: textblock
en: Locale::Po4a::Chooser is a module to manage po4a modules. Previously, all po4a binaries used to know all po4a modules (pod, man, sgml, etc). This made the addition of a new module boring, because you had to make sure that the documentation is synchronized in all modules, and that each of them can access the new module.
it: Locale::Po4a::Chooser è un modulo che gestisce gli altri moduli di po4a. Prima che esistesse, tutti i programmi di po4a dovevano sapere dell'esistenza di tutti i moduli (pod, man, sgml, etc.); questa situazione rendeva difficile e noiosa l'aggiunta di nuovi moduli, poiché ci si doveva preoccupare che la documentazione fosse sincronizzata in tutti i moduli e che ognuno di essi potesse accedere al nuovo modulo.

note: type: textblock
en: Now, you just have to call the Locale::Po4a::Chooser::new() function, passing the name of module as argument.
it: Ora invece è sufficiente chiamare la funzione Locale::Po4a::Chooser::new(), passandole come argomento il nome del modulo.

note: type: textblock
en: The function Locale::Po4a::Chooser::list() lists the available formats, and exits with the value passed as argument. So, we call Locale::Po4a::Chooser::list(0) when requested for the list of formats, and Locale::Po4a::Chooser::list(1) when passed an invalid format name.
it: La funzione Locale::Po4a::Chooser::list() elenca i formati disponibili, ed esce con il valore passato come argomento. Perciò, si chiama Locale::Po4a::Chooser::list(0) quando si richiede l'elenco dei formati, e Locale::Po4a::Chooser::list(1) quando viene passato un nome formato non valido.

note: type: =item
en: About po4a:
it: Informazioni su po4a:

note: type: =item
en: About modules:
it: Informazioni sui moduli:

note: type: textblock
en: L<Locale::Po4a::Dia(3pm)>, L<Locale::Po4a::Docbook(3pm)>, L<Locale::Po4a::Guide(3pm)>, L<Locale::Po4a::Halibut(3pm)>, L<Locale::Po4a::Ini(3pm)>, L<Locale::Po4a::KernelHelp(3pm)>, L<Locale::Po4a::LaTeX(3pm)>, L<Locale::Po4a::Man(3pm)>, L<Locale::Po4a::Pod(3pm)>, L<Locale::Po4a::RubyDoc(3pm)>, L<Locale::Po4a::Sgml(3pm)>, L<Locale::Po4a::TeX(3pm)>, L<Locale::Po4a::Texinfo(3pm)>, L<Locale::Po4a::Text(3pm)>, L<Locale::Po4a::Wml(3pm)>.  L<Locale::Po4a::Xhtml(3pm)>, L<Locale::Po4a::Xml(3pm)>, L<Locale::Po4a::Wml(3pm)>, L<Locale::Po4a::Yaml(3pm)>.
it: L<Locale::Po4a::Dia(3pm)>, L<Locale::Po4a::Docbook(3pm)>, L<Locale::Po4a::Guide(3pm)>, L<Locale::Po4a::Halibut(3pm)>, L<Locale::Po4a::Ini(3pm)>, L<Locale::Po4a::KernelHelp(3pm)>, L<Locale::Po4a::LaTeX(3pm)>, L<Locale::Po4a::Man(3pm)>, L<Locale::Po4a::Pod(3pm)>, L<Locale::Po4a::RubyDoc(3pm)>, L<Locale::Po4a::Sgml(3pm)>, L<Locale::Po4a::TeX(3pm)>, L<Locale::Po4a::Texinfo(3pm)>, L<Locale::Po4a::Text(3pm)>, L<Locale::Po4a::Wml(3pm)>.  L<Locale::Po4a::Xhtml(3pm)>, L<Locale::Po4a::Xml(3pm)>, L<Locale::Po4a::Wml(3pm)>.

note: type: textblock
en: Copyright © 2002-2005, 2014, 2017 SPI, Inc.
it: Copyright © 2002-2005, 2014, 2017 by SPI, inc.

note: type: textblock
en: Locale::Po4a::Common - common parts of the po4a scripts and utils
it: Locale::Po4a::Common - parti comuni ai moduli e agli script di po4a

note: type: textblock
en: Locale::Po4a::Common contains common parts of the po4a scripts and some useful functions used along the other modules.
it: Locale::Po4a::Common contiene delle parti comuni agli script di po4a e qualche funzione generica usata dagli altri moduli.

note: type: textblock
en: If needed, you can disable the use of Text::WrapI18N as such:
it: Se serve, si può disabilitare l'uso di Text::WrapI18N in questo modo:

note: type: textblock
en: instead of:
it: invece di:

note: type: textblock
en: The ordering is important here: as most Locale::Po4a modules load themselves Locale::Po4a::Common, the first time this module is loaded determines whether Text::WrapI18N is used.
it: L'ordine qui è importante: dato che la maggior parte dei moduli di Locale::Po4a caricano Locale::Po4a::Common, la prima volta che questo modulo viene caricato determina se viene usato Text::WrapI18N.

note: type: =head1
en: FUNCTIONS
it: FUNZIONI

note: type: =head2
en: Showing output messages
it: Visualizzazione dei messaggi di output.

note: type: textblock
en: Shows the current version of the script, and a short copyright message. It takes the name of the script as an argument.
it: Mostra la versione attuale dello script, insieme a un breve messaggio di copyright. Richiede il nome dello script come argomento.

note: type: textblock
en: This function displays a message the same way as sprintf() does, but wraps the result so that they look nice on the terminal.
it: Questa funzione mostra un messaggio allo stesso modo di come fa sprintf(), ma fa andare a capo il risultato in modo da migliorarne l'aspetto sul terminale.

note: type: textblock
en: This function works like wrap_msg(), but it takes a module name as the first argument, and leaves a space at the left of the message.
it: Questa funzione è simile a wrap_msg(), ma riceve il nome di un modulo come primo argomento e lascia uno spazio a sinistra del messaggio.

note: type: textblock
en: This function works like wrap_msg(), but it takes a file:line reference as the first argument, a module name as the second one, and leaves a space at the left of the message.
it: Questa funzione è simile a wrap_msg(), ma riceve un riferimento del tipo "file:riga" come primo argomento, il nome di un modulo come secondo argomento e lascia uno spazio a sinistra del messaggio.

note: type: =head2
en: Wrappers for other modules
it: Wrapper per altri moduli

note: type: textblock
en: When the Locale::Gettext module cannot be loaded, this module provide dummy (empty) implementation of the following functions. In that case, po4a messages won't get translated but the program will continue to work.
it: Quando il modulo Locale::Gettext non può essere caricato, questo modulo fornisce una implementazione fantoccio (vuota) delle seguenti funzioni. In tal caso, i messaggi po4a non verranno tradotti ma il programma continuerà a funzionare.

note: type: textblock
en: If Locale::gettext is present, this wrapper also calls setlocale(LC_MESSAGES, "") so callers don't depend on the POSIX module either.
it: Se Locale::gettext è presente, questo wrapper chiama anche setlocale(LC_MESSAGES, "") in modo tale che i chiamanti non dipendano nemmeno dal modulo POSIX.

note: type: textblock
en: Copyright © 2005 SPI, Inc.
it: Copyright © 2005 by SPI, inc.

note: type: textblock
en: Locale::Po4a::Dia - convert uncompressed Dia diagrams from/to PO files
it: Locale::Po4a::Dia - converte diagrammi Dia non compressi da/verso file PO

note: type: textblock
en: Locale::Po4a::Dia is a module to help the translation of diagrams in the uncompressed Dia format into other [human] languages.
it: Locale::Po4a::Dia è un modulo che aiuta la traduzione in altre lingue dei diagrammi Dia in formato non compresso.

note: type: verbatim
en: You can get Dia (the graphical editor for these diagrams) from:
      http://www.gnome.org/projects/dia/
it: È possibile trovare Dia (l'editor grafico per questi diagrammi) su:
      http://www.gnome.org/projects/dia/

note: type: =head1
en: TRANSLATING WITH PO4A::DIA
it: TRADURRE CON PO4A::DIA

note: type: textblock
en: This module only translates uncompressed Dia diagrams.  You can save your uncompressed diagrams with Dia itself, unchecking the "Compress diagram files" at the "Save Diagram" dialog.
it: Questo modulo traduce solamente i diagrammi Dia non compressi. È possibile salvare i diagrammi in formato non compresso direttamente usando Dia, basta deselezionare l'opportuna casella di controllo nella finestra di salvataggio.

note: type: verbatim
en: Another way is to uncompress the dia files from command line with:
      gunzip < original.dia > uncompressed.dia
it: Si possono anche decomprimere i file dalla linea di comando con:
      gunzip < originale.dia > noncompresso.dia

note: type: textblock
en: This module is fully functional, as it relies in the L<Locale::Po4a::Xml> module. This only defines the translatable tags (E<lt>dia:stringE<gt>), and filters the internal strings (the content of the E<lt>dia:diagramdataE<gt> tag), not interesting for translation.
it: Questo modulo è perfettamente funzionante, dal momento che si limita a definire i tag traducibili (E<lt>dia:stringE<gt>) e a scartare le stringhe ad uso interno (contenute nel tag E<lt>dia:diagramdataE<gt>), che non vanno tradotte. Tutto il lavoro viene svolto dal modulo L<Locale::Po4a::Xml>.

note: type: textblock
en: Locale::Po4a::Docbook - convert DocBook XML documents from/to PO files
it: Locale::Po4a::Docbook - converte documenti DocBook XML da/verso file PO

note: type: textblock
en: Locale::Po4a::Docbook is a module to help the translation of DocBook XML documents into other [human] languages.
it: Locale::Po4a::Docbook è un modulo che aiuta la traduzione in altre lingue della documentazione in formato DocBook XML.

note: type: textblock
en: This module is fully functional, as it relies in the L<Locale::Po4a::Xml> module. This only defines the translatable tags and attributes.
it: Questo modulo è perfettamente funzionante, dal momento che si limita a definire i tag e gli attributi traducibili. Tutto il lavoro viene svolto dal modulo L<Locale::Po4a::Xml>.

note: type: textblock
en: The only known issue is that it doesn't handle entities yet, and this includes the file inclusion entities, but you can translate most of those files alone (except the typical entities files), and it's usually better to maintain them separated.
it: L'unico problema conosciuto è che ancora non gestisce le entità, nemmeno le «file inclusion entities»; è comunque possibile tradurre separatamente la maggior parte di questi file (tranne i «typical entity files») e, di solito, è meglio mantenerli divisi.

note: type: =head2
en: OVERRIDE THE DEFAULT BEHAVIOR WITH COMMAND LINE OPTIONS
it: SUPERARE IL COMPORTAMENTO PREDEFINITO CON OPZIONI DA RIGA DI COMANDO

note: type: textblock
en: The default behavior of system provided modules is set to be on the safe side.
it: Il comportamento predefinito dei moduli forniti dal sistema è impostato sulla sicurezza.

note: type: textblock
en: For example, the default of B<< <author> >> tag is aiming it to appear under B<< <para> >>.  But you may be using it only under B<< <bookinfo> >>.  For this case, you may want to translate it independently for each author.
it: Per esempio, l'impostazione predefinita del marcatore B<< <author> >> è di apparire sotto B<< <para> >>.  Ma si potrebbe essere nella condizione di usarlo solo sotto B<< <bookinfo> >>.  In questo caso, si potrebbe volerlo tradurre indipendentemente per ogni autore.

note: type: textblock
en: If you don't like the default behavior of the xml module and its derivative modules, you can provide command line options to change their behavior.  For example, you can add the following to the po4a configuration file:
it: Se non soddisfa il comportamento predefinito del modulo xml e dei suoi moduli derivati, si può fornire opzioni sulla riga di comando per cambiare il loro comportamento. Per esempio, si può aggiungere al file di configurazione di po4a le seguenti opzioni:

note: type: textblock
en: This overrides the default behavior for B<< <bookinfo> >> and B<< <author> >>, set B<< <bookinfo> >> and B<< <author> >> to break input data stream on these tags, set B<< <bookinfo> >> not to translate its tagged content, and set B<< <author> >> to translate its tagged content.
it: Questo supera il comportamento predefinito per B<< <bookinfo> >> e B<< <author> >>, imposta B<< <bookinfo> >> e B<< <author> >> per interrompere il flusso dati in ingresso su questi marcatori, imposta B<< <bookinfo> >> a non tradurre il suo contenuto, e imposta B<< <author> >> invece per tradurre il suo contenuto.

note: type: verbatim
en:  Copyright © 2004 Jordi Vilalta  <jvprat@gmail.com>
     Copyright © 2007-2009 Nicolas François <nicolas.francois@centraliens.net>
it:  Copyright (c) 2004 by Jordi Vilalta  <jvprat@gmail.com>
     Copyright (c) 2007-2009 by Nicolas François <nicolas.francois@centraliens.net>

note: type: textblock
en: Locale::Po4a::Guide - convert Guide XML documents from/to PO files
it: Locale::Po4a::Guide - converte documenti Guide XML da/verso file PO

note: type: textblock
en: Locale::Po4a::Guide is a module to help in the translation of the Gentoo Linux documentation in the Guide XML format into other [human] languages.
it: Locale::Po4a::Guide è un modulo che aiuta la traduzione in altre lingue della documentazione di Gentoo Linux in formato Guide XML.

note: type: textblock
en: This format is documented here: http://www.gentoo.org/doc/en/xml-guide.xml
it: La documentazione di questo formato si trova presso: http://www.gentoo.org/doc/it/xml-guide.xml

note: type: textblock
en: The only known issue is that it doesn't include files with the <include href="..."> tag, but you can translate all those files alone, and it's usually better to have them separated.
it: L'unico problema conosciuto è che il tag <include href="..."> non include nessun file; è comunque possibile tradurre separatamente ciascuno di questi file e, di solito, è meglio mantenerli divisi.

note: type: textblock
en: Locale::Po4a::Halibut - convert Halibut documents and derivates from/to PO files
it: Locale::Po4a::Halibut - converte documenti Halibut e derivati da/a file PO

note: type: textblock
en: Locale::Po4a::Halibut is a module to help the translation of Halibut documents into other [human] languages.
it: Locale::Po4a::Halibut è un modulo che serve ad aiutare la traduzione di documenti Halibut in altre lingue.

note: type: textblock
en: This module contains the definitions of common Halibut commands and environments.
it: Questo modulo contiene le definizioni di comuni comandi ed ambienti Halibut.

note: type: textblock
en: This module is still beta.  Please send feedback and feature requests.
it: Questo modulo è ancora in fase beta. Si prega di fare rapporto sul funzionamento e per le richieste di funzionalità.

note: type: =head1
en: CAVEAT
it: ATTENZIONE

note: type: textblock
en: Some constructs are badly supported. The known ones are documented below.
it: Alcuni costrutti non sono ben supportati. Quelli noti sono documentati di seguito.

note: type: =head2
en: Verbatim blocks
it: Blocchi verbatim

note: type: textblock
en: The verbatim block is not considered as a whole. Each line will be translated separately.
it: Il blocco verbatim non è considerato un tutt'uno. Ogni riga verrà tradotta separatamente.

note: type: textblock
en: Copyright © 2004-2008 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
it: Copyright © 2004-2008 by Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.

note: type: textblock
en: This program is free software; you may redistribute it and/or modify it under the terms of GPL (see COPYING file).
it: Questo programma è software libero; è lecito ridistribuirlo o modificarlo secondo i termini della licenza GPL (vedere il file COPYING).

note: type: textblock
en: Locale::Po4a::Ini - convert INI files from/to PO files
it: Locale::Po4a::Ini - converte file INI da/a file PO

note: type: textblock
en: Locale::Po4a::Ini is a module to help the translation of INI files into other [human] languages.
it: Locale::Po4a::Ini è un modulo che aiuta la traduzione in altre lingue dei file in formato INI.

note: type: textblock
en: The module searches for lines of the following format and extracts the quoted text:
it: Il modulo cerca le righe corrispondenti al seguente formato e ne estrae il testo virgolettato:

note: type: textblock
en: identificator="text than can be translated"
it: identificatore="testo che può essere tradotto"

note: type: textblock
en: NOTE: If the text is not quoted, it will be ignored.
it: NOTA: se il testo non è virgolettato, verrà ignorato.

note: type: textblock
en: Locale::Po4a::KernelHelp - convert kernel configuration help from/to PO files
it: Locale::Po4a::KernelHelp - converte l'aiuto della configurazione del kernel da/verso file PO

note: type: textblock
en: Locale::Po4a::KernelHelp is a module to help the translation of documentation for the Linux kernel configuration options into other [human] languages.
it: Locale::Po4a::KernelHelp è un modulo che aiuta la traduzione in altre lingue della documentazione delle opzioni di configurazione del kernel Linux.

note: type: textblock
en: This module is just written, and needs more tests. Most of the needed work will concern the tools used to parse this file (and configure the kernel), so that they accept to read the documentation from another (translated)  file.
it: Questo modulo è stato scritto da poco e ha bisogno di essere testato. Bisogna ancora lavorare molto sugli strumenti di configurazione del kernel, facendo sì che accettino di leggere la documentazione da un altro file (quello tradotto).

note: type: textblock
en: Copyright © 2002 SPI, Inc.
it: Copyright © 2002 SPI, inc.

note: type: textblock
en: Locale::Po4a::LaTeX - convert LaTeX documents and derivates from/to PO files
it: Locale::Po4a::LaTeX - Converte documenti LaTeX e derivati da/a file PO

note: type: textblock
en: Locale::Po4a::LaTeX is a module to help the translation of LaTeX documents into other [human] languages. It can also be used as a base to build modules for LaTeX-based documents.
it: Locale::Po4a::LaTeX è un modulo che aiuta la traduzione in altre lingue della documentazione in formato LaTeX. Può anche essere usato come base per scrivere moduli per documenti basati su LaTeX.

note: type: textblock
en: This module contains the definitions of common LaTeX commands and environments.
it: Questo modulo contiene le definizioni di comuni comandi ed ambienti LaTex.

note: type: textblock
en: See the L<Locale::Po4a::TeX(3pm)|Locale::Po4a::TeX> manpage for the list of recognized options.
it: Consultare la magina man di L<Locale::Po4a::TeX(3pm)|Locale::Po4a::TeX> per ottenere l'elenco delle opzioni riconosciute.

note: type: textblock
en: Locale::Po4a::Man - convert manual pages from/to PO files
it: Locale::Po4a::Man - converte pagine di manuale da/a file PO

note: type: textblock
en: Locale::Po4a::Man is a module to help the translation of documentation in the nroff format (the language of manual pages) into other [human] languages.
it: Locale::Po4a::Man è un modulo che aiuta la traduzione in altre lingue della documentazione in formato nroff (il linguaggio delle pagine di manuale).

note: type: =head1
en: TRANSLATING WITH PO4A::MAN
it: TRADURRE CON PO4A::MAN

note: type: textblock
en: This module tries pretty hard to make translator's life easier. For that, the text presented to translators isn't a verbatim copy of the text found in the man page. Indeed, the cruder parts of the nroff format are hidden, so that translators can't mess up with them.
it: Questo modulo prova fortemente a facilitare la vita ai traduttori. Per far ciò, il testo presentato ai traduttori non è una fotocopia del testo trovato nella pagina man. Infatti, le parti più grezze del formato nroff vengono nascoste, in modo che i traduttori non possano rovinarle.

note: type: =head2
en: Text wrapping
it: A capo del testo

note: type: textblock
en: Unindented paragraphs are automatically rewrapped for the translator.  This can lead to some minor difference in the generated output, since the rewrapping rules used by groff aren't very clear. For example, two spaces after a parenthesis are sometimes preserved.
it: I paragrafi non indentati vengono formattati automaticamente per il traduttore.  Ciò può portare ad alcune differenze minori nel risultato generato, dato che le regole del portare a capo usate da groff non sono molto chiare. Per esempio, due spazi dopo una parentesi alle volte vengono conservati.

note: type: textblock
en: Anyway, the difference will only be about the position of the extra spaces in wrapped paragraph, and I think it's worth.
it: Comunque, la differenza riguarderà solamente la posizione degli spazi extra nei paragrafi riformattati, e dovrebbe valere la pena.

note: type: =head2
en: Font specification
it: Indicazione font

note: type: textblock
en: The first change is about font change specifications.  In nroff, there are several ways to specify if a given word should be written in small, bold or italics. In the text to translate, there is only one way, borrowed from the POD (Perl online documentation) format:
it: Il primo cambiamento riguarda le specifiche del cambiamento del font.  In nroff, ci sono diversi modi per specificare se una data parola dovrebbe essere scritta in minuscolo, grassetto o corsivo. Nel testo da tradurre, c'è un unico modo, preso a prestito dal formato POD (Perl online documentation):

note: type: =item
en: IE<lt>textE<gt> -- italic text
it: IE<lt>testoE<gt> -- testo in corsivo

note: type: textblock
en: equivalent to \fItext\fP or ".I text"
it: equivalente a \fItesto\fP o ".I testo"

note: type: =item
en: BE<lt>textE<gt> -- bold text
it: BE<lt>testoE<gt> -- testo in grassetto

note: type: textblock
en: equivalent to \fBtext\fP or ".B text"
it: equivalente a \fBtesto\fP or ".B testo"

note: type: =item
en: RE<lt>textE<gt> -- roman text
it: RE<lt>testoE<gt> -- testo con grazie

note: type: textblock
en: equivalent to \fRtext\fP
it: equivalente a \fRtesto\fP

note: type: =item
en: CWE<lt>textE<gt> -- constant width text
it: CWE<lt>testoE<gt> -- testo a larghezza costante

note: type: textblock
en: equivalent to \f(CWtext\fP or ".CW text"
it: equivalente a \f(CWtesto\fP or ".CW testo"

note: type: textblock
en: Remark: The CW face is not available for all groff devices. It is not recommended to use it. It is provided for your convenience.
it: Nota: il CW face non è disponibile per tutti i dispositivi groff. Se ne sconsiglia l'uso. Viene fornito solo per comodità dell'utente.

note: type: =head2
en: Automatic characters transliteration
it: Transliterazione automatica caratteri

note: type: textblock
en: Po4a automatically transliterate some characters to ease the translation or the review of the translation.  Here is the list of the transliterations:
it: Po4a automaticamente translitera alcuni caratteri per facilitarne la traduzione o la revisione della traduzione.  Ecco l'elenco delle transliterazioni:

note: type: =item
en: hyphens
it: trattino

note: type: textblock
en: Hyphens (-) and minus signs (\-) in man pages are all transliterated as simple dashes (-) in the PO file.  Then all dash are transliterated into roff minus signs (\-) when the translation is inserted into the output document.
it: Trattini (-) e segni meno (\-) nelle pagine man vengono transliterati come semplici lineette (-) nei file PO.  Poi tutte le lineette sono transliterate in segni meno di roff (\-) quando la traduzione viene inserita nel documento in uscita.

note: type: textblock
en: Translators can force an hyphen by using the roff glyph '\[hy]' in their translations.
it: I traduttori possono forzare un trattino usando il glifo roff '\[hy]' nelle loro traduzioni.

note: type: =item
en: non-breaking spaces
it: spazi non interrompenti

note: type: textblock
en: Translators can use non-breaking spaces in their translations.  These non-breaking spaces (0xA0 in latin1) will be transliterated into a roff non-breaking space ('\ ').
it: I traduttori possono usare spazi non interrompenti nelle loro traduzioni.  Questi spazi non interrompenti (0xA0 in latin1) verranno transliterati in uno spazio non interrompente roff ('\ ').

note: type: =item
en: quotes transliterations
it: transliterazione apici

note: type: textblock
en: `` and '' are respectively tranliterated into \*(lq and \*(rq.
it: `` e '' vengono transliterati rispettivamente in \*(lq e \*(rq.

note: type: textblock
en: To avoid these transliterations, translators can insert a zero width roff character (i.e., using `\&` or '\&' respectively).
it: Per evitare queste transliterazioni, i traduttori possono inserire un carattere nroff di larghezza zero (cioè, usando rispettivamente `\&` o '\&').

note: type: =head2
en: Putting 'E<lt>' and 'E<gt>' in translations
it: Mettere 'E<lt>' e 'E<gt>' nelle traduzioni

note: type: textblock
en: Since these chars are used to delimit parts under font modification, you can't use them verbatim. Use EE<lt>ltE<gt> and EE<lt>gtE<gt> instead (as in POD, one more time).
it: Siccome questi caratteri vengono usati per delimitare parti sottoposte a modifiche del font, non si possono usare direttamente. In alternativa si consiglia di usare EE<lt>ltE<gt> e EE<lt>gtE<gt> (ancora una volta, come nei POD).

note: type: textblock
en: Activate debugging for some internal mechanisms of this module.  Use the source to see which parts can be debugged.
it: Attiva il debug per alcuni meccanismi interni di questo modulo.  Usare i sorgenti per vedere quali parti possono essere controllate.

note: type: textblock
en: Increase verbosity.
it: Rende il programma più prolisso.

note: type: textblock
en: This option controls the behavior of the module when it encounter a .de, .ie or .if section. It can take the following values:
it: Questa opzione controlla il comportamento del modulo quando questo incontra una sezione un .de, .ie o .if . Può prendere i seguenti valori:

note: type: textblock
en: This is the default value.  The module will fail when a .de, .ie or .if section is encountered.
it: È il valore predefinito.  Il modulo fallirà quando incontrerà una sezione .de, .ie o .if .

note: type: textblock
en: Indicates that the .de, .ie or .if sections must be copied as is from the original to the translated document.
it: Indica che le sezioni .de, .ie o .if devono venir copiate come sono dall'originale nel documento tradotto.

note: type: textblock
en: Indicates that the .de, .ie or .if sections will be proposed for the translation.  You should only use this option if a translatable string is contained in one of these section. Otherwise, I<verbatim> should be preferred.
it: Indica che le sezioni .de, .ie o .if verranno proposte per la traduzione.  Si dovrebbe usare questa opzione solo se una stringa traducibile fosse presente in una di dette sezioni. Altrimenti, sarebbe preferibile I<verbatim>.

note: type: textblock
en: This option specifies that the file was generated, and that po4a should not try to detect if the man pages was generated from another format.  This option is mandatory to use po4a on generated man pages.  Note that translating generated pages instead of sources ones is often more fragile, and thus a bad idea.
it: Questa opzione specifica che il file è un file generato, e che quindi po4a non dovrebbe cercare di rilevare se le pagine man siano state generate da un altro formato. Questa opzione è necessaria per usare po4a su pagine man generate. Si noti che tradurre pagine generate invece di quelle sorgenti è spesso più fragile (N.d.T: è più facile fare errori), e quindi una cattiva idea.

note: type: textblock
en: This option is only useful for mdoc pages.
it: Questa opzione è utile solo per le pagine mdoc.

note: type: textblock
en: It selects a stricter support of the mdoc format by telling po4a not to translate the 'NAME' section.  mdoc pages whose 'NAME' section is translated won't generate any header or footer.
it: Seleziona un supporto più stringente del formato mdoc indicando a po4a di non tradurre la sezione 'NAME'. Le pagine mdoc la cui sezione 'NAME' è tradotta non genereranno alcuna intestazione o piè di pagina.

note: type: verbatim
en: According to the groff_mdoc page, the NAME, SYNOPSIS and DESCRIPTION
    sections are mandatory.
    There are no known issues with translated SYNOPSIS or DESCRIPTION section,
    but you can also specify these sections this way:
     -o mdoc=NAME,SYNOPSIS,DESCRIPTION
it: Secondo la pagina groff_mdoc, le sezioni NOME, SINTASSI e DESCRIZIONE
    sono obbligatorie.
    Non sembrano esserci problemi conosciuti nel tradurre le sezioni SINTASSI
    o DESCRIZIONE, ma si può specificare queste sezioni anche in questo modo:
     -o mdoc=NOME,SINTASSI,DESCRIZIONE

note: type: verbatim
en: This mdoc issue can also be solved with an addendum like this one:
     PO4A-HEADER:mode=before;position=^.Dd
     .TH DOCUMENT_TITLE 1 "Month day, year" OS "Section Name"
it: Questo problema di mdoc può essere risolto anche con un addendum come questo:
     PO4A-HEADER:mode=before;position=^.Dd
     .TH DOCUMENT_TITLE 1 "Month day, year" OS "Section Name"

note: type: textblock
en: The following options specify the behavior of a user-defined macro (with a .de request), or of a classical macro that is not supported by po4a.  They take as argument a comma-separated list of macros.  For example:
it: Le opzioni seguenti specificano il comportamento di una macro personalizzata (definita con una richiesta .de), o di una macro classica non supportata da po4a.  Prendono come argomento un elenco separato da virgole di macro.  Per esempio:

note: type: textblock
en: Note: if a macro is not supported by po4a and if you consider that it is a standard roff macro, you should submit it to the po4a development team.
it: Nota: se una macro macro non è supportata da po4a e si ritiene che sia una macro standard roff, sarebbe desiderabile comunicarlo al team di sviluppo di po4a (N.d.T. per un'eventuale inclusione in una prossima versione di po4a).

note: type: textblock
en: B<untranslated> indicates that this macro (at its arguments) don't have to be translated.
it: B<untranslated> indica che questa macro (ed i suoi argomenti) non deve essere tradotta.

note: type: textblock
en: B<noarg> is like B<untranslated>, except that po4a will verify that no argument is added to this macro.
it: B<noarg> è come B<untranslated>, eccetto per il fatto che po4a verificherà che non venga aggiunto nessun argomento a questa macro.

note: type: textblock
en: B<translate_joined> indicates that po4a must propose to translate the arguments of the macro.
it: B<translate_joined> indica che po4a deve proporre di tradurre gli argomenti della macro.

note: type: textblock
en: With B<translate_each>, the arguments will also be proposed for the translation, except that each one will be translated separately.
it: Anche con B<translate_each>, gli argomenti verranno proposti per la traduzione, ma ognuno verrà tradotto separatamente.

note: type: textblock
en: This option takes as argument a list of comma-separated couples I<begin>:I<end>, where I<begin> and I<end> are commands that delimit the begin and end of a section that should not be rewrapped.
it: Questa opzione prende come argomento un elenco di coppie separate da virgole I<begin>:I<end>, dove I<begin> e I<end> sono comandi che delimitano rispettivamente l'inizio e la fine di una sezione che non dovrebbe essere riformattata.

note: type: textblock
en: Note: no test is done to ensure that an I<end> command matches its I<begin> command; any ending command stop the no_wrap mode.  If you have a I<begin> (respectively I<end>) macro that has no I<end> (respectively I<begin>), you can specify an existing I<end> (like fi) or I<begin> (like nf) as a counterpart.  These macros (and their arguments) won't be translated.
it: Nota: non viene effettuata nessuna prova per assicurare che il comando I<end> corrisponda al suo comando I<begin>; qualunque comando di fine interrompe la modalità no_wrap.  Se si ha una macro I<begin> (o rispettivamente I<end>) che non ha un I<end> (o rispettivamente I<begin>), si può specificare un I<end> esistente (come fi) o I<begin> (come nf) come controparte.  Queste macro (ed i loro argomenti) non verranno tradotte.

note: type: textblock
en: This option specifies a list of comma-separated macros that must not split the current paragraph. The string to translate will then contain I<foo E<lt>.bar baz quxE<gt> quux>, where I<bar> is the command that should be inlined, and I<baz qux> its arguments.
it: Questa opzione specifica un elenco separato da virgole di macro che non devono spezzare il paragrafo corrente. La stringa da tradurre conterrà perciò I<foo E<lt>.bar baz quxE<gt> quux>, dove I<bar> è il comando che dovrebbe essere messo sulla stessa riga, e I<baz qux> i suoi argomenti.

note: type: textblock
en: This option indicates how po4a should behave when an unknown macro is found.  By default, po4a fails with a warning.  It can take the following values: B<failed> (the default value), B<untranslated>, B<noarg>, B<translate_joined>, or B<translate_each> (see above for an explanation of these values).
it: Questa opzione indica come po4a dovrebbe comportarsi quando trova una macro sconosciuta.  Per impostazione predefinita, po4a fallisce con un avvertimento.  Può prendere i seguenti valori: B<failed> (il valore predefinito), B<untranslated>, B<noarg>, B<translate_joined>, o B<translate_each> (vedere sopra per una spiegazione di questi valori).

note: type: =head1
en: AUTHORING MAN PAGES COMPLIANT WITH PO4A::MAN
it: CREAZIONE DI PAGINE COMPATIBILI MAN CON PO4A::MAN

note: type: textblock
en: This module is still very limited, and will always be, because it's not a real nroff interpreter. It would be possible to do a real nroff interpreter, to allow authors to use all the existing macros, or even to define new ones in their pages, but we didn't want to. It would be too difficult, and we thought it wasn't necessary. We do think that if manpages' authors want to see their productions translated, they may have to adapt to ease the work of translators.
it: Questo modulo è ancora molto limitato, e lo sarà sempre, perché non è un vero interprete nroff. Sarebbe possibile fare un vero interprete nroff, per consentire agli autori di utilizzare tutte le macro esistenti, o anche definirne di nuove nelle loro pagine, ma non abbiamo voluto. Sarebbe stato troppo difficile, e pensavamo che non fosse necessario. Pensiamo che se gli autori delle manpage vogliono vedere le loro produzioni tradotte, potrebbero doversi adattare per facilitare il lavoro dei traduttori.

note: type: textblock
en: So, the man parser implemented in po4a have some known limitations we are not really inclined to correct, and which will constitute some pitfalls you'll have to avoid if you want to see translators taking care of your documentation.
it: Perciò, il parser man implementato in po4a ha alcune limitazioni note, che non abbiamo intenzione di correggere, e che potranno presentare dei problemi che sarà necessario evitare se si vuole che i traduttori si prendano cura della propria documentazione.

note: type: =head2
en: Don't program in nroff
it: Non programmare in nroff

note: type: textblock
en: nroff is a complete programming language, with macro definition, conditionals and so on. Since this parser isn't a fully featured nroff interpreter, it will fail on pages using these facilities (There are about 200 such pages on my box).
it: nroff è un linguaggio di programmazione completo, con definizione di macro, condizionali e così via. Poiché questo parser non è un interprete nroff completo, non funzionerà sulle pagine che utilizzano queste funzionalità (ci sono circa 200 di queste pagine sul mio sistema).

note: type: =head2
en: Use the plain macro set
it: Usare l'insieme di macro di base

note: type: textblock
en: There are still some macros which are not supported by po4a::man. This is only because I failed to find any documentation about them. Here is the list of unsupported macros used on my box. Note that this list isn't exhaustive since the program fails on the first encountered unsupported macro. If you have any information about some of these macros, I'll happily add support for them. Because of these macros, about 250 pages on my box are inaccessible to po4a::man.
it: Ci sono ancora alcune macro che non sono supportate da po4a::man. Questo solo perché non siamo riusciti a trovare nessuna documentazione su di esse. Ecco l'elenco delle macro non supportate utilizzate sul mio sistema. Si noti che questo elenco non è esaustivo poiché il programma non riesce sulla prima macro non supportata incontrata. Se potete fornire informazioni su alcune di queste macro, aggiungeremo volentieri il supporto per esse. A causa di queste macro, circa 250 pagine del mio sistema sono inaccessibili a po4a::man.

note: type: =head2
en: Hiding text from po4a
it: Nascondere il testo a po4a

note: type: textblock
en: Sometimes, the author knows that some parts are not translatable, and should not be extracted by po4a. For example, an option may accept an I<other> argument, and I<other> may also appear as the last item of a list. In the first case, I<other> should be not be translatable. And in the second case, I<other> should be translated.
it: A volte, l'autore sa che alcune parti non vanno tradotte e non dovrebbero essere estratte da po4a. Ad esempio, un'opzione potrebbe accettare un argomento I<other> e I<other> potrebbe apparire anche come ultimo elemento di un elenco. Nel primo caso, I<other> non dovrebbe essere traducibile. E nel secondo caso, I<other> dovrebbe essere tradotto.

note: type: textblock
en: In such case, the author can avoid po4a to extract some strings, using some special groff constructs:
it: In tal caso, l'autore può evitare che po4a estragga alcune stringhe, utilizzando alcuni costrutti groff speciali:

note: type: textblock
en: (this will require the B<-o groff_code=verbatim> option)
it: (ciò richiederà l'opzione B<-o groff_code=verbatim>)

note: type: verbatim
en: A new macro can also be defined to automate this:
     .de IR_untranslated
     .    IR \\$@
     ..
it: Si può anche definire una nuova macro per automatizzare l'operazione:
     .de IR_untranslated
     .    IR \\$@
     ..

note: type: textblock
en: (this will require the options B<-o groff_code=verbatim> and B<-o untranslated=IR_untranslated>; with this construct, the B<.if !'po4a'hide'> conditional is not strictly needed since po4a will not parse the internal of the macro definition)
it: (questo richiederà le opzioni B<-o groff_code=verbatim> e B<-o untranslated=IR_untranslated>; con questo costrutto, il condizionale B<.if !'po4a'hide'> non è strettamente necessario dato che po4a non analizzerà l'interno della definizione della macro)

note: type: verbatim
en: or using an alias:
     .als IR_untranslated IR
it: o usando un'alias:
     .als IR_untranslated IR

note: type: textblock
en: This will require the B<-o untranslated=als,IR_untranslated> option.
it: Ciò richiederà l'opzione B<-o untranslated=als,IR_untranslated>.

note: type: =head2
en: Conclusion
it: Conclusione

note: type: textblock
en: To summarise this section, keep simple, and don't try to be clever while authoring your man pages. A lot of things are possible in nroff, and not supported by this parser. For example, don't try to mess with \c to interrupt the text processing (like 40 pages on my box do). Or, be sure to put the macro arguments on the same line that the macro itself. I know that it's valid in nroff, but would complicate too much the parser to be handled.
it: Per riassumere, fare le cose semplicemente non cercando trucchi complessi nella creazione delle pagine man. Molte cose possibili in nroff non sono supportate da questo parser. Ad esempio, non si provi a pasticciare con \c per interrompere l'elaborazione del testo (come fanno 40 pagine sul mio sistema). In alternativa, assicurarsi di inserire gli argomenti della macro sulla stessa unica riga della macro. È valido in nroff, ma complicherebbe troppo la gestione del parser.

note: type: textblock
en: Of course, another possibility is to use another format, more translator friendly (like POD using po4a::pod, or one of the XML family like SGML), but thanks to po4a::man it isn't needed anymore. That being said, if the source format of your documentation is POD, or XML, it may be clever to translate the source format and not this generated one. In most cases, po4a::man will detect generated pages and issue a warning. It will even refuse to process POD generated pages, because those pages are perfectly handled by po4a::pod, and because their nroff counterpart defines a lot of new macros I didn't want to write support for. On my box, 1432 of the 4323 pages are generated from POD and will be ignored by po4a::man.
it: Naturalmente, un'altra possibilità è usare un altro formato, più facile da tradurre (come il formato POD usando po4a::pod, o uno della famiglia XML come SGML), ma grazie a po4a::man, ciò non è comunque più necessario. Detto questo, se il formato sorgente della documentazione è POD o XML, potrebbe essere conveniente tradurre il formato sorgente e non quello generato. Nella maggior parte dei casi, po4a::man rileverà le pagine generate ed emetterà un avviso. Si rifiuterà persino di elaborare le pagine generate dal POD, perché quelle pagine sono perfettamente gestite da po4a::pod e perché la loro controparte nroff definisce molte nuove macro per le quali non si è voluto darne supporto. Per esempio, sulla macchina di uno degli autori, 1432 delle 4323 pagine presenti vengono generate da file POD e sono ignorate da po4a::man.

note: type: textblock
en: In most cases, po4a::man will detect the problem and refuse to process the page, issuing an adapted message. In some rare cases, the program will complete without warning, but the output will be wrong. Such cases are called "bugs" ;) If you encounter such case, be sure to report this, along with a fix when possible…
it: Nella maggior parte dei casi, po4a::man rileverà il problema e si rifiuterà di elaborare la pagina, inviando un messaggio conforme. In alcuni rari casi, il programma verrà completato senza preavviso, ma l'output sarà comunque errato. Tali casi sono chiamati "bug" ;) Se incontra un caso del genere, sarebbe gradita la segnalazione, insieme a una correzione se possibile...

note: type: textblock
en: This module can be used for most of the existing man pages.
it: Questo modulo può essere usato per la maggior parte delle pagine man esistenti.

note: type: textblock
en: Some tests are regularly run on Linux boxes:
it: Alcuni test vengono effettuati con regolarità su macchine Linux:

note: type: textblock
en: one third of the pages are refused because they were generated from another format supported by po4a (e.g. POD or SGML).
it: un terzo delle pagine vengono rifiutate perché sono state generate da un altro formato supportato da po4a (per es. POD o SGML).

note: type: textblock
en: 10% of the remaining pages are rejected with an error (e.g. a groff macro is not supported).
it: il 10% delle pagine rimanenti vengono rifiutate con un errore (perché per es. una macro groff non è supportata).

note: type: textblock
en: Then, less than 1% of the pages are accepted silently by po4a, but with significant issues (i.e. missing words, or new words inserted)
it: Poi, meno dell'1% delle pagine vengono accettate da po4a silenziosamente (N.d.T. ovvero senza segnalazioni), ma con problemi significativi (cioè parole mancanti, o nuove parole inserite)

note: type: textblock
en: The other pages are usually handled without differences more important than spacing differences or line rewrapped (font issues in less than 10% of the processed pages).
it: Le altre pagine vengono solitamente gestite senza differenze più rilevanti delle differenze di spaziatura o dell'andare a capo delle righe (problemi relativi ai font in meno del 10% delle pagine elaborate).

note: type: textblock
en: Copyright © 2002-2008 SPI, Inc.
it: Copyright © 2002-2008 by SPI, inc.

note: type: textblock
en: Locale::Po4a::Po - PO file manipulation module
it: Locale::Po4a::Po - Modulo per la manipolazione di file PO

note: type: verbatim
en:     # Read PO file
        $pofile->read('file.po');
it:     # Leggi il file PO
        $pofile->read('file.po');

note: type: verbatim
en:     # Add an entry
        $pofile->push('msgid' => 'Hello', 'msgstr' => 'bonjour',
                      'flags' => "wrap", 'reference'=>'file.c:46');
it:     # Aggiungi una voce
        $pofile->push('msgid' => 'Hello', 'msgstr' => 'bonjour',
                      'flags' => "wrap", 'reference'=>'file.c:46');

note: type: verbatim
en:     # Extract a translation
        $pofile->gettext("Hello"); # returns 'bonjour'
it:     # Estrai una traduzione
        $pofile->gettext("Hello"); # restituisce 'Ciao'

note: type: verbatim
en:     # Write back to a file
        $pofile->write('otherfile.po');
it:     # Restituisce scrivendo in un file
        $pofile->write('otherfile.po');

note: type: textblock
en: Locale::Po4a::Po is a module that allows you to manipulate message catalogs. You can load and write from/to a file (which extension is often I<po>), you can build new entries on the fly or request for the translation of a string.
it: Locale::Po4a::Po è un modulo che permette di elaborare cataloghi di messaggi. Si può caricare e scrivere da/verso un file (la cui estensione è spesso I<po>), si possono creare nuove voci al volo o a richiesta per la traduzione di una stringa.

note: type: textblock
en: For a more complete description of message catalogs in the PO format and their use, please refer to the info documentation of the gettext program (node "`PO Files"').
it: Per una descrizione più approfondita dei cataloghi di messaggi in formato PO e sul loro uso, fare riferimento alla documentazione info del programma gettext (nodo "`PO Files"').

note: type: textblock
en: This module is part of the po4a project, which objective is to use PO files (designed at origin to ease the translation of program messages) to translate everything, including documentation (man page, info manual), package description, debconf templates, and everything which may benefit from this.
it: Questo modulo fa parte del progetto po4a, il cui obiettivo è di usare file PO (progettati originariamente per semplificare la traduzione dei messaggi dei programmi) per tradurre qualunque cosa, inclusa la documentazione (pagine man, manuali info), descrizione pacchetti, modelli debconf, e tutto ciò che potrebbe trarne giovamento.

note: type: =head1
en: Functions concerning entire message catalogs
it: Funzioni concernenti interi cataloghi di messaggi

note: type: textblock
en: Creates a new message catalog. If an argument is provided, it's the name of a PO file we should load.
it: Crea un nuovo catalogo di messaggi. Se viene fornito un argomento, è il nome del file PO che bisognerebbe caricare.

note: type: textblock
en: Reads a PO file (which name is given as argument).  Previously existing entries in self are not removed, the new ones are added to the end of the catalog.
it: Legge un file PO (il cui nome viene dato come argomento). Voci preesistenti in esso non vengono rimosse, le nuove vengono aggiunte alla fine del catalogo.

note: type: textblock
en: Writes the current catalog to the given file.
it: Scrive il catalogo corrente nel file dato.

note: type: textblock
en: Like write, but if the PO or POT file already exists, the object will be written in a temporary file which will be compared with the existing file to check if the update is needed (this avoids to change a POT just to update a line reference or the POT-Creation-Date field).
it: Come write, ma se il file PO o POT esiste già, l'oggetto verrà scritto in un file temporaneo che verrà confrontato con il file esistente per controllare se l'aggiornamento è necessario (ciò evita di cambiare un file POT solo per aggiornare una riga di riferimento o il campo POT-Creation-Date).

note: type: textblock
en: This function extracts a catalog from an existing one. Only the entries having a reference in the given file will be placed in the resulting catalog.
it: Questa funzione estrae un catalogo da uno esistente. Solo le voci con riferimento nel file dato verranno inserite nel catalogo risultante.

note: type: textblock
en: This function parses its argument, converts it to a Perl function definition, evals this definition and filters the fields for which this function returns true.
it: Questa funzione analizza il suo argomento, lo converte in una definizione di funzione Perl, valuta questa definizione e filtra i campi per i quali questa funzione restituisce vero.

note: type: textblock
en: I love Perl sometimes ;)
it: Amo Perl alle volte ;)

note: type: textblock
en: Recodes to UTF-8 the PO's msgstrs. Does nothing if the charset is not specified in the PO file ("CHARSET" value), or if it's already UTF-8 or ASCII.
it: Ricodifica in UTF-8 le msgstrs del PO. Non fa nulla se il set di caratteri non è specificato nel file PO (il valore di "CHARSET"), o se è già UTF-8 o ASCII.

note: type: =head1
en: Functions to use a message catalog for translations
it: Funzioni che usano un catalogo messaggi per le traduzioni

note: type: textblock
en: Request the translation of the string given as argument in the current catalog.  The function returns the original (untranslated) string if the string was not found.
it: Richiede la traduzione della stringa data come argomento, nel catalogo corrente. La funzione restituisce la stringa originale (non tradotta) se la stringa non viene trovata.

note: type: textblock
en: After the string to translate, you can pass a hash of extra arguments. Here are the valid entries:
it: Dopo la stringa da tradurre, si può passare un hash di argomenti extra. Ecco le voci accettate:

note: type: textblock
en: boolean indicating whether we can consider that whitespaces in string are not important. If yes, the function canonizes the string before looking for a translation, and wraps the result.
it: booleano indicante se si può considerare gli spazi bianchi nella stringha come non importanti. Se si, la funzione canonizza la stringa prima di cercare una traduzione, e formatta il risultato.

note: type: textblock
en: the column at which we should wrap (default: 76).
it: la colonna a cui andare a capo (valore predefinito: 76).

note: type: textblock
en: Returns statistics about the hit ratio of gettext since the last time that stats_clear() was called. Please note that it's not the same statistics than the one printed by msgfmt --statistic. Here, it's statistics about recent usage of the PO file, while msgfmt reports the status of the file.  Example of use:
it: Restituisce le statistiche sulla percentuale di successo di gettext dall'ultima volta che è stato chiamato stats_clear(). Si noti che non sono le stesse statistiche di quelle stampate da msgfmt --statistic. Qui, sono le statistiche sull'utilizzo recente del file PO, mentre msgfmt riporta lo stato del file. Esempio d'uso:

note: type: verbatim
en:     [some use of the PO file to translate stuff]
it:     [alcuni usi del file PO per tradurre cose]

note: type: verbatim
en:     ($percent,$hit,$queries) = $pofile->stats_get();
        print "So far, we found translations for $percent\%  ($hit of $queries) of strings.\n";
it:     ($percent,$hit,$queries) = $pofile->stats_get();
        print "Si qui, sono state trovate traduzioni per il $percent\% ($hit di $queries) delle stringhe.\n";

note: type: textblock
en: Clears the statistics about gettext hits.
it: Cancella le statistiche generate da gettext.

note: type: =head1
en: Functions to build a message catalog
it: Funzioni per creare un catalogo messaggi

note: type: textblock
en: Push a new entry at the end of the current catalog. The arguments should form a hash table. The valid keys are:
it: Aggiunge una nuova voce alla fine del catalogo corrente. Gli argomenti dovrebbero formare una tabella hash. Le chiavi valide sono:

note: type: textblock
en: the string in original language.
it: la stringa nella lingua originale.

note: type: textblock
en: the translation.
it: la traduzione.

note: type: textblock
en: an indication of where this string was found. Example: file.c:46 (meaning in 'file.c' at line 46). It can be a space-separated list in case of multiple occurrences.
it: un'indicazione di dove è stata trovata questa stringa. Esempio: file.c:46 (che significa in 'file.c' alla riga 46). Può essere un elenco separato da spazi in caso di più occorrenze.

note: type: textblock
en: a comment added here manually (by the translators). The format here is free.
it: un commento aggiunto manualmente (dal traduttore). Il formato è libero.

note: type: textblock
en: a comment which was automatically added by the string extraction program. See the B<--add-comments> option of the B<xgettext> program for more information.
it: un commento che è stato aggiunto automaticamente dal programma di estrazione delle stringhe. Vedere l'opzione B<--add-comments> del programma B<xgettext> per maggiori informazioni.

note: type: textblock
en: space-separated list of all defined flags for this entry.
it: elenco separato da spazi di tutte le flag definite per questa voce.

note: type: textblock
en: Valid flags are: B<c-text>, B<python-text>, B<lisp-text>, B<elisp-text>, B<librep-text>, B<smalltalk-text>, B<java-text>, B<awk-text>, B<object-pascal-text>, B<ycp-text>, B<tcl-text>, B<wrap>, B<no-wrap> and B<fuzzy>.
it: Flag validi sono: B<c-text>, B<python-text>, B<lisp-text>, B<elisp-text>, B<librep-text>, B<smalltalk-text>, B<java-text>, B<awk-text>, B<object-pascal-text>, B<ycp-text>, B<tcl-text>, B<wrap>, B<no-wrap> e B<fuzzy>.

note: type: textblock
en: See the gettext documentation for their meaning.
it: Consultare la documentazione di gettext per conoscerne il significato.

note: type: textblock
en: this is mostly an internal argument: it is used while gettextizing documents. The idea here is to parse both the original and the translation into a PO object, and merge them, using one's msgid as msgid and the other's msgid as msgstr. To make sure that things get ok, each msgid in PO objects are given a type, based on their structure (like "chapt", "sect1", "p" and so on in DocBook). If the types of strings are not the same, that means that both files do not share the same structure, and the process reports an error.
it: questo è principalmente un argomento interno: viene utilizzato durante la gettext-izzazione di documenti. Il concetto è, analizzare sia l'originale che la traduzione in un oggetto PO e poi unirli, usando il msgid di uno come msgid e il msgid dell'altro come msgstr. Per assicurarsi che le cose vadano bene, a ogni msgstr negli oggetti PO viene assegnato un tipo, in base alla loro struttura (come "chapt", "sect1", "p" e così via in DocBook). Se i tipi di stringhe non sono gli stessi, significa che entrambi i file non condividono la stessa struttura e il processo segnala un errore.

note: type: textblock
en: This information is written as automatic comment in the PO file since this gives to translators some context about the strings to translate.
it: Questa informazione viene scritta come commento automatico nel file PO poiché ciò fornisce ai traduttori un contesto sulle stringhe da tradurre.

note: type: textblock
en: boolean indicating whether whitespaces can be mangled in cosmetic reformattings. If true, the string is canonized before use.
it: booleano che indica se gli spazi bianchi possono essere alterati nelle riformattazioni cosmetiche. Se vero, la stringa viene canonizzata prima dell'uso.

note: type: textblock
en: This information is written to the PO file using the B<wrap> or B<no-wrap> flag.
it: Questa informazione viene scritta nel file PO usando i flag B<wrap> o B<no-wrap>.

note: type: textblock
en: This information is not written to the PO file.
it: Questa informazione non viene scritta nel file PO.

note: type: =head1
en: Miscellaneous functions
it: Funzioni varie

note: type: textblock
en: Returns the number of entries in the catalog (without the header).
it: Restituisce il numero delle voci nel catalogo (senza l'intestazione).

note: type: textblock
en: Returns the number of entries in document. If a string appears multiple times in the document, it will be counted multiple times.
it: Restituisce il numero delle voci nel documento. Se una stringa compare più volte nel documento, verrà contata più volte.

note: type: textblock
en: Returns the msgid of the given number.
it: Restituisce il msgid del numero dato.

note: type: textblock
en: Returns the msgid with the given position in the document.
it: Restituisce il msgid con la data posizione nel documento.

note: type: textblock
en: Returns the type of the msgid with the given position in the document. This is probably only useful to gettextization, and it's stored separately from {$msgid}{'type'} because the later location may be overwritten by another type when the $msgid is duplicated in the master document.
it: Restituisce il tipo di msgid con la posizione specificata nel documento. Probabilmente utile solo per ottenere la gettext-izzazione, ed è memorizzato separatamente da {$msgid}{'type'} perché la posizione successiva potrebbe essere sovrascritta da un altro tipo quando $msgid viene duplicato nel documento master.

note: type: textblock
en: Returns the character set specified in the PO header. If it hasn't been set, it will return "UTF-8".
it: Rstituisce il set di carattere specificato nell'intestazione del file PO. Se non è stato impostato, restituirà "UTF-8".

note: type: textblock
en: This sets the character set of the PO header to the value specified in its first argument. If you never call this function (and no file with a specified character set is read), the default value is left to "UTF-8". This value doesn't change the behavior of this module, it's just used to fill that field in the header, and to return it in get_charset().
it: Questo imposta il set di caratteri dell'intestazione PO al valore specificato nel suo primo argomento. Se non si chiama mai questa funzione (e quindi non viene letto alcun file con uno specifico set di caratteri), il valore predefinito viene lasciato a "UTF-8". Questo valore non cambia il comportamento di questo modulo: viene usato solo per riempire quel campo nell'intestazione e per restituirlo in get_charset().

note: type: textblock
en: Locale::Po4a::Pod - convert POD data from/to PO files
it: Locale::Po4a::Pod - converte documenti POD da/a file PO

note: type: verbatim
en:     # Read POD from STDIN and write to STDOUT.
        $parser->parse_from_filehandle;
it:     # Legge il file POD da STDIN e scrive su STDOUT.
        $parser->parse_from_filehandle;

note: type: verbatim
en:     # Read POD from file.pod and write to file.txt.
        $parser->parse_from_file ('file.pod', 'file.txt');
it:     # Legge il file POD da file.pod e scrive su file.txt.
        $parser->parse_from_file ('file.pod', 'file.txt');

note: type: textblock
en: Locale::Po4a::Pod is a module to help the translation of documentation in the POD format (the preferred language for documenting Perl) into other [human] languages.
it: Locale::Po4a::Pod è un modulo che aiuta la traduzione in altre lingue della documentazione in formato POD (il linguaggio preferito per la documentazione di Perl).

note: type: textblock
en: I think that this module is rock stable, and there is only one known bug with F</usr/lib/perl5/Tk/MainWindow.pod> (and some other pages, see below) which contains:
it: Questo modulo è ritenuto perfettamente stabile ed è noto solo un bug:Ho un altro problema con F</usr/lib/perl5/Tk/MainWindow.pod> (e qualche altra pagina, vedere più avanti) che contiene:

note: type: textblock
en: Lack of luck, in the po4a version, this was split on the space by the wrapping. As result, in the original version, the man page contains
it: La sfortuna ha voluto che, nella versione di po4a, questo è stato mandato a capo dove c'è lo spazio. Come risultato, la versione originale contiene

note: type: textblock
en: and mine contains
it: e la mia contiene

note: type: textblock
en: which is logic since CE<lt>foobarE<gt> is rewritten "foobar".
it: che è logico, dato che CE<lt>blablaE<gt> viene riscritto come "blabla".

note: type: textblock
en: Complete list of pages having this problem on my box (from 564 pages; note that it depends on the chosen wrapping column): /usr/lib/perl5/Tk/MainWindow.pod /usr/share/perl/5.8.0/overload.pod /usr/share/perl/5.8.0/pod/perlapi.pod /usr/share/perl/5.8.0/pod/perldelta.pod /usr/share/perl/5.8.0/pod/perlfaq5.pod /usr/share/perl/5.8.0/pod/perlpod.pod /usr/share/perl/5.8.0/pod/perlre.pod /usr/share/perl/5.8.0/pod/perlretut.pod
it: Elenco completo delle pagine con questo problema che si trovano sul mio computer (da 564 pagine; notare che dipende dalla colonna scelta per il ritorno a capo automatico): /usr/lib/perl5/Tk/MainWindow.pod /usr/share/perl/5.8.0/overload.pod /usr/share/perl/5.8.0/pod/perlapi.pod /usr/share/perl/5.8.0/pod/perldelta.pod /usr/share/perl/5.8.0/pod/perlfaq5.pod /usr/share/perl/5.8.0/pod/perlpod.pod /usr/share/perl/5.8.0/pod/perlre.pod /usr/share/perl/5.8.0/pod/perlretut.pod

note: type: =head1
en: INTERNALS
it: FUNZIONAMENTO INTERNO

note: type: textblock
en: As a derived class from Pod::Parser, Locale::Po4a::Pod supports the same methods and interfaces.  See L<Pod::Parser> for all the details; briefly, one creates a new parser with C<< Locale::Po4a::Pod->new() >> and then calls either parse_from_filehandle() or parse_from_file().
it: Come classe derivata da Pod::Parser, Locale::Po4a::Pod supporta gli stessi metodi e la stessa interfaccia. Vedere anche L<Pod::Parser> per maggiori dettagli; in breve, si crea un nuovo parser con C<< Locale::Po4a::Pod->new() >>, dopodiché si effettua una chiamata a parse_from_filehandle() o parse_from_file().

note: type: textblock
en: new() can take options, in the form of key/value pairs, that control the behavior of the parser.  The recognized options common to all Pod::Parser children are:
it: new() può accettare opzioni, in forma di coppie chiave/valore, che controllano il comportamento del parser. Le opzioni riconosciute da tutti i discendenti di Pod::Parser sono:

note: type: textblock
en: If set to a true value, selects an alternate output format that, among other things, uses a different heading style and marks B<=item> entries with a colon in the left margin.  Defaults to false.
it: Se il suo valore è true, seleziona un formato di output alternativo che, tra le altre cose, usa un diverso stile di intestazione e segna le voci B<=item> con dei due punti sul margine sinistro. Il valore predefinito è false.

note: type: textblock
en: If set to a true value, the non-POD parts of the input file will be included in the output.  Useful for viewing code documented with POD blocks with the POD rendered and the code left intact.
it: Se il suo valore è true, le parti non POD del file di input saranno incluse nell'output. Può essere utile per visualizzare del codice documentato con POD: i blocchi POD verranno impaginati, mentre il codice verrà lasciato intatto.

note: type: textblock
en: The number of spaces to indent regular text, and the default indentation for B<=over> blocks.  Defaults to 4.
it: Il numero di spazi da usare per indentare il testo normale e il rientro predefinito per i blocchi B<=over>. Il valore predefinito è 4.

note: type: textblock
en: If set to a true value, a blank line is printed after a B<=head1> heading.  If set to false (the default), no blank line is printed after B<=head1>, although one is still printed after B<=head2>.  This is the default because it's the expected formatting for manual pages; if you're formatting arbitrary text documents, setting this to true may result in more pleasing output.
it: Se il suo valore è true, verrà lasciata una riga vuota dopo un'intestazione B<=head1>. Se invece vale false (il valore predefinito), non ci sarà nessuna riga vuotà dopo B<=head1>, sebbene ne venga aggiunta una dopo B<=head2>. Il valore predefinito rispecchia l'aspetto standard delle pagine di manuale; se si sta impaginando un documento di un altro tipo, impostare a true può produrre un output più leggibile.

note: type: textblock
en: Sets the quote marks used to surround CE<lt>> text.  If the value is a single character, it is used as both the left and right quote; if it is two characters, the first character is used as the left quote and the second as the right quote; and if it is four characters, the first two are used as the left quote and the second two as the right quote.
it: Sceglie i segni da usare come virgolette per il testo racchiuso tra CE<lt>>. Se il valore è un singolo carattere, verrà usato sia a sinistra che a destra; se comprende due caratteri, il primo verrà usato come virgoletta sinistra, l'altro come virgoletta destra; se invece comprende quattro caratteri, i primi due staranno a sinistra e gli altri due a destra.

note: type: textblock
en: This may also be set to the special value B<none>, in which case no quote marks are added around CE<lt>> text.
it: È anche possibile usare il valore speciale B<none> per omettere completamente le virgolette attorno a CE<lt>>.

note: type: textblock
en: If set to a true value, Locale::Po4a::Pod will assume that each sentence ends in two spaces, and will try to preserve that spacing.  If set to false, all consecutive whitespace in non-verbatim paragraphs is compressed into a single space.  Defaults to true.
it: Se il suo valore è true, Locale::Po4a::Pod suppone che ogni frase finisca con due spazi e cercherà di conservare tale stile di spaziatura. Se invece vale false, tutti gli spazi consecutivi (eccetto che nei paragrafi da riportare invariati) verranno compressi in un singolo spazio. Il valore predefinito è true.

note: type: textblock
en: The column at which to wrap text on the right-hand side.  Defaults to 76.
it: La colonna a cui mandare a capo il testo sul margine destro. Il valore predefinito è 76.

note: type: textblock
en: Locale::Po4a::RubyDoc -- Convert Ruby Document data from/to PO files
it: Locale::Po4a::RubyDoc -- Converte dati Ruby Document da/a file PO

note: type: textblock
en: Locale::Po4a::RubyDoc is a module to help the translation of documentation in the Ruby Document (RD) format (a language used to document Ruby) into other [human] languages.
it: Locale::Po4a::RubyDoc è un modulo che serve per aiutare la traduzione della documentazione in formato Ruby Document (RD) (formato usato nella documentazione dei programmi Ruby) in altre lingue.

note: type: textblock
en: This module has been successfully tested on simple Ruby Document files covering a good part of the format syntax.
it: Questo modulo è stato controllato con successo su semplici file Ruby Document, i quali coprivano buona parte della sintassi del formato.

note: type: textblock
en: A known limitation is that it fails to properly recognize the stacked structure of input Ruby Document: this implies that when, for instance, an EnumListItem consists of more than one Block, only the first Block is actually recognized as EnumListItem, while the subsequent ones are considered just as TextBlocks...
it: Una limitazione nota è che non viene riconosciuta correttamente la struttura impilata del Ruby Document in ingresso: questo implica che quando, ad esempio, un EnumListItem è composto da più di un Block, solo il primo Block viene effettivamente riconosciuto come EnumListItem, mentre i successivi vengono considerati solo come TextBlock...

note: type: textblock
en: This module supports the following option:
it: Questo modulo supporta le seguenti opzioni:

note: type: textblock
en: Handle files entirely made of Ruby Document formatted text (without any "=begin" line).
it: Gestire file interamente composti da testo formattato Ruby Document (senza alcuna riga "=begin").

note: type: textblock
en: By default, this module only handles Ruby Document formatted text between "=begin" and "=end" lines (hence ignoring, among other things, everything that precedes the first "=begin" line).
it: Per impostazione predefinita, questo modulo gestisce solo il testo formattato in Ruby Document tra le righe "=begin" e "=end" (ignorando quindi, tra l'altro, tutto ciò che precede la prima riga "=begin").

note: type: textblock
en: This work is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
it: Questo lavoro è software libero; puoi ridistribuirlo e/o modificarlo secondo i termini della GNU General Public License come pubblicata dalla Free Software Foundation; la versione 2 della licenza o (a propria scelta) qualsiasi versione successiva.

note: type: textblock
en: This work is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
it: Quest'opera è distribuita nella speranza che possa essere utile, ma SENZA ALCUNA GARANZIA; senza nemmeno la garanzia implicita di COMMERCIABILITÀ o IDONEITÀ PER UN PARTICOLARE SCOPO. Vedi la GNU General Public License per maggiori dettagli.

note: type: textblock
en: You should have received a copy of the GNU General Public License along with this work; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
it: Dovresti aver ricevuto una copia della GNU General Public License insieme a questo lavoro; in caso contrario, scrivi alla Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

note: type: textblock
en: Parts of the code (such as many regular expressions) were adapted from the source of rdtool, under the terms of the GNU General Public License, version 2 or later.  These parts are originally:
it: Parti del codice (come molte espressioni regolari) sono state adattate dal sorgente di rdtool, secondo i termini della GNU General Public License, versione 2 o successiva. Queste parti sono originariamente:

note: type: textblock
en: The initialize code was adapted from the source of Locale::Po4a::Text, under the terms of the GNU General Public License, version 2 or later.  This code was originally:
it: Il codice di inizializzazione è stato adattato dai sorgenti di Locale::Po4a::Text, secondo i termini della GNU General Public License, versione 2 o successiva. Questo codice era originariamente:

note: type: textblock
en: Locale::Po4a::Sgml - convert SGML documents from/to PO files
it: Locale::Po4a::Sgml - converte documenti SGML da/a file PO

note: type: textblock
en: Locale::Po4a::Sgml is a module to help the translation of documentation in the SGML format into other [human] languages.
it: Locale::Po4a::Sgml è un modulo che aiuta la traduzione in altre lingue della documentazione in formato SGML.

note: type: textblock
en: This module uses B<onsgmls>(1) to parse the SGML files. Make sure it is installed.  Also make sure that the DTD of the SGML files are installed in the system.
it: Questo modulo usa B<onsgmls>(1) per analizzare i file SGML. Assicurati che sia installato. Assicurati anche che i DTD dei file SGML siano installati nel sistema.

note: type: textblock
en: Space separated list of keywords indicating which part you want to debug. Possible values are: tag, generic, entities and refs.
it: Elenco di parole chiave, separate da spazi, indicanti le parti di cui fare il debug. I valori ammessi sono: «tag», «generic», «entities» e «refs».

note: type: textblock
en: Give more information about what's going on.
it: Mostra più informazioni su quello che sta accadendo.

note: type: textblock
en: Space separated list of extra tags (beside the DTD provided ones) whose content should form an extra msgid.
it: Elenco separato da spazi di tag extra (oltre a quelli forniti da DTD) il cui contenuto dovrebbe formare un msgstr in più.

note: type: textblock
en: Space separated list of extra tags (beside the DTD provided ones)  containing other tags, some of them being of category B<translate>.
it: Elenco separato da spazi di tag extra (oltre a quelli forniti dalla DTD) contenenti altri tag, alcuni dei quali sono di categoria B<translate>.

note: type: textblock
en: Space separated list of tags which increase the indentation level.
it: Elenco separato da spazi di tag che aumentano il livello di indentazione.

note: type: textblock
en: The layout within those tags should not be changed. The paragraph won't get wrapped, and no extra indentation space or new line will be added for cosmetic purpose.
it: Il layout all'interno di questi tag non deve essere modificato: i paragrafi non verranno mandati a capo, non verrà aumentata l'indentazione né verranno aggiunte nuove linee per ragioni estetiche.

note: type: textblock
en: Tags not needing to be closed.
it: Tag che non è necessario chiudere.

note: type: textblock
en: Tags ignored and considered as plain char data by po4a. That is to say that they can be part of an msgid. For example, E<lt>bE<gt> is a good candidate for this category since putting it in the translate section would create msgids not being whole sentences, which is bad.
it: Tag ignorati e considerati come testo semplice da po4a, vale a dire che possono far parte di un msgid. Ad esempio, E<lt>bE<gt> è un buon candidato per questa categoria: metterlo nella sezione traducibile darebbe luogo a dei msgid che non contengono frasi complete, condizione non ideale.

note: type: textblock
en: A space separated list of attributes that need to be translated. You can specify the attributes by their name (for example, "lang"), but you can also prefix it with a tag hierarchy, to specify that this attribute will only be translated when it is into the specified tag. For example: E<lt>bbbE<gt>E<lt>aaaE<gt>lang specifies that the lang attribute will only be translated if it is in an E<lt>aaaE<gt> tag, which is in a E<lt>bbbE<gt> tag.  The tag names are actually regular expressions so you can also write things like E<lt>aaa|bbbbE<gt>lang to only translate lang attributes that are in an E<lt>aaaE<gt> or a E<lt>bbbE<gt> tag.
it: Un elenco di attributi separati da spazi che devono essere tradotti. È possibile specificare gli attributi in base al loro nome (ad esempio, "lang"), ma è anche possibile anteporre una gerarchia di tag, per specificare che questo attributo verrà tradotto solo quando si trova nel tag specificato. Ad esempio: E<lt>bbbE<gt>E<lt>aaaE<gt>lang specifica che l'attributo lang verrà tradotto solo se si trova in un tag E<lt>aaaE<gt>, che è in un tag E<lt>bbbE<gt>. I nomi dei tag sono in realtà espressioni regolari, quindi si possono anche scrivere cose come E<lt>aaa|bbbbE<gt>lang per tradurre solo attributi lang che sono in nei tag E<lt>aaaE<gt> o E<lt>bbbE<gt>.

note: type: textblock
en: A space separated list of attributes for which the translation must be qualified by the attribute name. Note that this setting automatically adds the given attribute into the 'attributes' list too.
it: Un elenco di attributi separati da spazi per i quali la traduzione deve essere qualificata dal nome dell'attributo. Si noti che questa impostazione aggiunge automaticamente l'attributo dato anche nell'elenco 'attributes'.

note: type: textblock
en: Proceed even if the DTD is unknown or if onsgmls finds errors in the input file.
it: Procede anche se il DTD è sconosciuto o se onsgmls trova errori nel file in ingresso.

note: type: textblock
en: By default, msgids containing only one entity (like '&version;') are skipped for the translator comfort. Activating this option prevents this optimisation. It can be useful if the document contains a construction like "<title>&Aacute;</title>", even if I doubt such things to ever happen...
it: I msgid che contengono solo un'entità (come «&version;») vengono saltati per comodità del traduttore. Attivare questa opzione impedisce questa ottimizzazione. Può essere utile se il documento contiene una costruzione del tipo «<title>&Egrave;</title>», anche se è difficile possa succedere...

note: type: textblock
en: Space separated list of entities that won't be inlined.  Use this option with caution: it may cause onsgmls (used internally) to add tags and render the output document invalid.
it: Elenco separato da spazi di entità che non saranno accodate.  Usare quest'opzione con cautela: può provocare in onsgmls (usato internamente) l'aggiunta di tag ed invalidare così il documento in uscita.

note: type: textblock
en: The result is perfect. I.e., the generated documents are exactly the same. But there are still some problems:
it: Il risultato è perfetto, ossia i documenti generati sono identici. Rimane però ancora qualche problema:

note: type: textblock
en: The error output of onsgmls is redirected to /dev/null by default, which is clearly bad. I don't know how to avoid that.
it: Gli errori scritti in uscita da onsgmls vengono rediretti in maniera predefinita su /dev/null, il che è chiaramente sbagliato, ma non so come fare per evitarlo.

note: type: textblock
en: The problem is that I have to "protect" the conditional inclusions (i.e. the C<E<lt>! [ %foo [> and C<]]E<gt>> stuff) from onsgmls. Otherwise onsgmls eats them, and I don't know how to restore them in the final document. To prevent that, I rewrite them to C<{PO4A-beg-foo}> and C<{PO4A-end}>.
it: Il problema è che devo "proteggere" l'inclusione condizionale (cioè i vari C<E<lt>! [ %blabla [> e C<]]E<gt>>) da onsgmls. Altrimenti onsgmls se li mangia e non so come fare per farli ricomparire nel documento finale. Per impedirlo, li riscrivo come C<{PO4A-beg-foo}> e C<{PO4A-end}>.

note: type: textblock
en: The problem with this is that the C<{PO4A-end}> and such I add are invalid in the document (not in a E<lt>pE<gt> tag or so).
it: Il problema con questo approccio è che i vari C<{PO4A-end}> che aggiungo non sono validi nel documento (non in un tag E<lt>pE<gt> o simili).

note: type: textblock
en: If you want to view the onsgmls output, just add the following to your command line (or po4a configuration line):
it: Se si vuole visualizzare l'uscita di onsgmls, aggiungere quanto segue alla riga di comando (o alla riga di configurazione di po4a):

note: type: textblock
en: It does work only with the DebianDoc and DocBook DTD. Adding support for a new DTD should be very easy. The mechanism is the same for every DTD, you just have to give a list of the existing tags and some of their characteristics.
it: Funziona solo con i DTD DebianDoc e DocBook. Aggiungere supporto per un nuovo dtd dovrebbe essere molto facile. Il meccanismo è lo stesso per ogni DTD, basta soltanto fornire l'elenco dei tag esistenti e alcune delle loro caratteristiche.

note: type: textblock
en: I agree, this needs some more documentation, but it is still considered as beta, and I hate to document stuff which may/will change.
it: Sono d'accordo, avrebbe bisogno di maggiore documentazione, ma è ancora considerato in fase di beta, e detesto documentare qualcosa che potrebbe venir modificato in seguito.

note: type: textblock
en: Warning, support for DTDs is quite experimental. I did not read any reference manual to find the definition of every tag. I did add tag definition to the module 'till it works for some documents I found on the net. If your document use more tags than mine, it won't work. But as I said above, fixing that should be quite easy.
it: Attenzione, il supporto per i DTD è piuttosto sperimentale. Non ho letto nessun manuale di riferimento per trovare le definizioni di tutti i tag. Ho aggiunto definizioni dei tag al modulo finché non ha funzionato per qualche documento che ho trovato in rete. Non funzionerà se il documento fornito usa più tag del mio. Ma, come ho appena detto, sistemarlo dovrebbe essere davvero facile.

note: type: textblock
en: I did test DocBook against the SAG (System Administrator Guide) only, but this document is quite big, and should use most of the DocBook specificities.
it: Ho testato DocBook soltanto con SAG (acronimo di System Administrator Guide, la famosa Guida degli amministratori di sistema di Linux), ma si tratta di un documento piuttosto grosso, e dovrebbe usare gran parte delle caratteristiche di DocBook.

note: type: textblock
en: For DebianDoc, I tested some of the manuals from the DDP, but not all yet.
it: Per quanto riguarda DebianDoc, ho testato qualche manuale del DDP, ma non ancora tutti.

note: type: textblock
en: In case of file inclusion, string reference of messages in PO files (i.e. lines like C<#: en/titletoc.sgml:9460>) will be wrong.
it: Nel caso in cui si includano file, i riferimenti ai messaggi nei file po (cioè le righe del tipo C<#: en/titletoc.sgml:9460>) risulteranno sbagliati.

note: type: textblock
en: This is because I preprocess the file to protect the conditional inclusion (i.e. the C<E<lt>! [ %foo [> and C<]]E<gt>> stuff) and some entities (like &version;) from onsgmls because I want them verbatim to the generated document. For that, I make a temp copy of the input file and do all the changes I want to this before passing it to onsgmls for parsing.
it: Questo perché prima il file viene pre-elaborato per proteggere l'inclusione condizionale (cioè i vari C<E<lt>! [ %blabla [> e C<]]E<gt>>) e qualche entità (come &version;) da onsgmls perché le voglio così come sono nel documento generato. Per questo motivo, faccio una copia temporanea del file di input e applico alla copia tutte le modifiche che voglio prima di sottoporlo all'analisi di onsgmls.

note: type: textblock
en: So that it works, I replace the entities asking for a file inclusion by the content of the given file (so that I can protect what needs to be in a subfile also). But nothing is done so far to correct the references (i.e., filename and line number) afterward. I'm not sure what the best thing to do is.
it: Per far sì che funzioni, sostituisco le entità che richiedono l'inclusione di un file con il contenuto del file dato (così posso proteggere anche ciò che si deve trovare anche nei sotto-file). Ma nulla viene fatto fin'ora per correggere i riferimenti (cioè i nomi dei file e i numeri di riga) successivamente. Non sono sicuro di quale sia la cosa migliore da fare.

note: type: textblock
en: This module is an adapted version of sgmlspl (SGML postprocessor for the ONSGMLS parser) which was:
it: Questo modulo è un adattamento di sgmlspl, (un postprocessore SGML per il parser ONSGMLS) che era:

note: type: verbatim
en:  Copyright © 1995 David Megginson <dmeggins@aix1.uottawa.ca>
it:  Copyright © 1995 by David Megginson <dmeggins@aix1.uottawa.ca>

note: type: textblock
en: The adaptation for po4a was done by:
it: Adattato per po4a da:

note: type: verbatim
en:  Copyright © 1995 David Megginson <dmeggins@aix1.uottawa.ca>.
     Copyright © 2002-2005 SPI, Inc.
it:  Copyright © 1995 by David Megginson <dmeggins@aix1.uottawa.ca>
     Copyright © 2002-2005 by SPI, inc.

note: type: textblock
en: Locale::Po4a::TeX - convert TeX documents and derivatives from/to PO files
it: Locale::Po4a::TeX - converte documenti TeX e derivati da/a file PO

note: type: textblock
en: Locale::Po4a::TeX is a module to help the translation of TeX documents into other [human] languages. It can also be used as a base to build modules for TeX-based documents.
it: Locale::Po4a::TeX è un modulo che aiuta la traduzione in altre lingue della documentazione in formato TeX. Può anche essere usato come base per scrivere moduli per documenti basati su TeX.

note: type: textblock
en: Users should probably use the LaTeX module, which inherits from the TeX module and contains the definitions of common LaTeX commands.
it: Gli utenti dovrebbero probabilmente usare il modulo LaTeX, che eredita dal modulo TeX e contiene le definizioni di tipici comandi LaTeX.

note: type: =head1
en: TRANSLATING WITH PO4A::TEX
it: TRADURRE CON PO4A::TEX

note: type: textblock
en: This module can be used directly to handle generic TeX documents.  This will split your document in smaller blocks (paragraphs, verbatim blocks, or even smaller like titles or indexes).
it: Questo modulo può essere usato direttamente per gestire generici documenti TeX. Dividerà il documento in blocchi più piccoli (paragrafi, blocchi verbatim o anche più piccoli come titoli o indici).

note: type: textblock
en: There are some options (described in the next section) that can customize this behavior.  If this doesn't fit to your document format you're encouraged to write your own derivative module from this, to describe your format's details.  See the section B<WRITING DERIVATIVE MODULES> below, for the process description.
it: Ci sono alcune opzioni (descritte nella sezione successiva) che possono personalizzare questo comportamento.  Se questo non dovesse adattarsi sufficientemente al formato del proprio documento si incoraggia a scriverne uno per il proprio modulo derivandolo da questo, per descrivere i dettagli del proprio formato. Consultare la prossima sezione B<SCRIVERE MODULI DERIVATI> più sotto, per la descrizione del processo.

note: type: textblock
en: This module can also be customized by lines starting with "% po4a:" in the TeX file. This process is described in the B<INLINE CUSTOMIZATION> section.
it: Questo modulo può essere personalizzato anche da righe che comincino con "% po4a:" nel file TeX. Queste personalizzazioni sono descritte nella sezione B<PERSONALIZZAZIONE INLINE>.

note: type: textblock
en: Comma-separated list of environments which should not be re-wrapped.
it: Elenco separato da virgole di ambienti che non dovrebbero essere mandati a capo.

note: type: textblock
en: Note that there is a difference between verbatim and no_wrap environments.  There is no command and comments analysis in verbatim blocks.
it: Si noti che c'è una differenza tra ambienti verbatim e no_wrap. Non c'è analisi comandi e commenti nei blocchi verbatim.

note: type: textblock
en: If this environment was not already registered, po4a will consider that this environment does not take any parameters.
it: Se questo ambiente non fosse già registrato, po4a considererà che questo ambiente non usi nessun parametro.

note: type: textblock
en: Colon-separated list of files that should not be included by \input and \include.
it: Elenco di file separato da simboli di due punti che non dovrebbero essere inclusi da \input e \include.

note: type: textblock
en: Comma-separated list of environments which should be taken as verbatim.
it: Elenco separato da virgole di ambienti che devono essere lasciati inalterati.

note: type: textblock
en: Use these options to override the default behavior of the defined commands.
it: L'uso di queste opzioni permette di scavalcare il comportamento predefinito dei comandi definiti.

note: type: textblock
en: The TeX module can be customized with lines starting by B<% po4a:>.  These lines are interpreted as commands to the parser.  The following commands are recognized:
it: Il modulo TeX può essere personalizzato con righe che cominciano con B<% po4a:>.  Queste righe vengono interpretate come comandi passati al parser. I comandi seguenti sono riconosciuti:

note: type: =item
en: B<% po4a: command> I<command1> B<alias> I<command2>
it: B<% po4a: command> I<comando1> B<alias> I<comando2>

note: type: textblock
en: Indicates that the arguments of the I<command1> command should be treated as the arguments of the I<command2> command.
it: Indica che gli argomenti del comando I<comando1> devono essere trattati come argomenti del comando I<comando2>.

note: type: =item
en: B<% po4a: command> I<command1> I<parameters>
it: B<% po4a: command> I<comando1> I<parametri>

note: type: textblock
en: This describes in detail the parameters of the I<command1> command.  This information will be used to check the number of arguments and their types.
it: Questo descrivere in dettaglio i parametri del comando I<comando1>.  Questa informazione verrà usata per controllare il numero di argomenti ed i loro tipi.

note: type: textblock
en: You can precede the I<command1> command by
it: Si può precedere il comando I<comando1> da

note: type: =item
en: an asterisk (B<*>)
it: un asterisco (B<*>)

note: type: textblock
en: po4a will extract this command from paragraphs (if it is located at the beginning or the end of a paragraph).  The translators will then have to translate the parameters that are marked as translatable.
it: po4a estrarrà questo comando dai paragrafi (se è posizionato all'inizio o alla fine del paragrafo).  I traduttori dovranno allora tradurre i parametri marcati come traducibili.

note: type: =item
en: a plus (B<+>)
it: un segno più (B<+>)

note: type: textblock
en: As for an asterisk, the command will be extracted if it appear at an extremity of a block, but the parameters won't be translated separately.  The translator will have to translate the command concatenated to all its parameters.  This keeps more context, and is useful for commands with small words in parameter, which can have multiple meanings (and translations).
it: Come per un asterisco, il comando verrà estratto se appare ad un'estremità di un blocco, ma i parametri non saranno tradotti separatamente.  Il traduttore dovrà tradurre il comando concatenato a tutti i suoi parametri.  Ciò mantiene più contesto, ed è utile per comandi con piccole parole nei parametri, che possono avere significati (e traduzioni) multipli.

note: type: textblock
en: Note: In this case you don't have to specify which parameters are translatable, but po4a must know the type and number of parameters.
it: Nota: in questo caso non è necessario specificare quali parametri sono traducibili, ma po4a deve sapere il tipo e numero di parametri.

note: type: =item
en: a minus (B<->)
it: un segno meno (B<->)

note: type: textblock
en: In this case, the command won't be extracted from any block.  But if it appears alone on a block, then only the parameters marked as translatable will be presented to the translator.  This is useful for font commands.  These commands should generally not be separated from their paragraph (to keep the context), but there is no reason to annoy the translator with them if a whole string is enclosed in such a command.
it: In questo caso, il comando non sarà estratto da nessun blocco. Ma se apparirà da solo in un blocco, allora solo i parametri marcati come traducibili saranno presentati al traduttore.  Ciò è utile per i comandi sui font.  Questi comandi generalmente non dovrebbero essere separati dai loro paragrafi (per mantenere il contesto), ma non c'è ragione di infastidire il traduttore con essi se un'intera stringa è racchiusa in un tale comando.

note: type: verbatim
en: The I<parameters> argument is a set of [] (to indicate an optional
    argument) or {} (to indicate a mandatory argument).
    You can place an underscore (_) between these brackets to indicate that
    the parameter must be translated. For example:
     % po4a: command *chapter [_]{_}
it: L'argomento I<parametri> è un insieme di [] (per indicare un argomento
    opzionale) o {} (per indicare un argomento obbligatorio). Si può
    piazzare un carattere di sottolineatura (_) tra queste parentesi
    per indicare che il parametro deve essere tradotto. Per esempio:
     % po4a: command *capitolo [_]{_}

note: type: verbatim
en: This indicates that the chapter command has two parameters: an optional
    (short title) and a mandatory one, which must both be translated.
    If you want to specify that the href command has two mandatory parameters,
    that you don't want to translate the URL (first parameter), and that you
    don't want this command to be separated from its paragraph (which allow
    the translator to move the link in the sentence), you can use:
     % po4a: command -href {}{_}
it: Questo indica che il comando del capitolo ha due parametri: uno opzionale
    (titolo corto) e uno obbligatorio, che devono entrambi essere tradotti.
    Se si vuole specificare che il comando href abbia due parametri obbligatori,
    che non si vuole tradurre l'URL (primo parametro), e che non si vuole
    che questo comando sia separato dal suo paragrafo (il che permette
    al traduttore di spostare il collegamento nel testo), si può usare:
     % po4a: command -href {}{_}

note: type: textblock
en: In this case, the information indicating which arguments must be translated is only used if a paragraph is only composed of this href command.
it: In questo caso, l'informazione indicante quali argomenti devono essere tradotti viene usata solo se un paragrafo è composto solo da questo comando href.

note: type: =item
en: B<% po4a: environment> I<env> I<parameters>
it: B<% po4a: environment> I<env> I<parametri>

note: type: verbatim
en: This defines the parameters accepted by the I<env> environment and specifies the ones to be translated.
    This information is later used to check the number of arguments of the
    \begin command.
    The syntax of the I<parameters> argument is the same as described for the
    others commands.
    The first parameter of the \begin command is the name of the environment.
    This parameter must not be specified in the list of parameters. Here are
    some examples:
     % po4a: environment multicols {}
     % po4a: environment equation
it: Questo definisce i parametri accettati dall'ambiente I<env> e specifica quelli che vanno tradotti.
    Questa informazione viene in seguito usata per controllare il numero di argomenti del comando \begin.
    La sintassi dell'argomento I<parameters> è la stessa descritta per gli
    altri comandi.
    Il primo parametro del comando \begin è il nome dell'ambiente.
    Questo parametro non deve essere specificato nell'elenco dei parametri.
    Ecco alcuni esempi:
     % po4a: environment multicols {}
     % po4a: environment equation

note: type: textblock
en: As for the commands, I<env> can be preceded by a plus (+) to indicate that the \begin command must be translated with all its arguments.
it: Come per i comandi, I<env> può essere preceduto da un più (+) per indicare che il comando \begin deve essere tradotto con tutti i suoi argomenti.

note: type: textblock
en: Indicates that an environment should be split according to the given regular expression.
it: Indica che un ambiente dovrebbe essere diviso secondo la data espressione regolare.

note: type: textblock
en: The regular expression is delimited by quotes.  It should not create any back-reference.  You should use (?:) if you need a group.  It may also need some escapes.
it: L'espressione regolare è delimitata da virgolette.  Non si dovrebbe creare nessun riferimento all'indietro. Si dovrebbe usare (?:) se serve un gruppo.  Potrebbero servire anche qualche carattere di escape.

note: type: textblock
en: For example, the LaTeX module uses the "(?:&|\\\\)" regular expression to translate separately each cell of a table (lines are separated by '\\' and cells by '&').
it: Ad esempio, il modulo LaTeX utilizza l'espressione regolare "(?:&|\\\\)" per tradurre separatamente ogni cella di una tabella (le righe sono separate da '\\' e le celle da '&').

note: type: textblock
en: The notion of environment is expanded to the type displayed in the PO file.  This can be used to split on "\\\\" in the first mandatory argument of the title command.  In this case, the environment is title{#1}.
it: La nozione di ambiente viene estesa al tipo visualizzato nel file PO. Ciò può essere usato per dividere su "\\\\" nel primo argomento obbligatorio del comando title. In questo caso, l'ambiente è title{#1}.

note: type: textblock
en: Indicate that I<env> is a verbatim environment.  Comments and commands will be ignored in this environment.
it: Indica che I<env> è un ambiente verbatim.  Commenti e comandi verranno ignorati in questo ambiente.

note: type: =head1
en: WRITING DERIVATE MODULES
it: SCRIVERE MODULI DERIVATI

note: type: textblock
en: Add a string as a comment to be added around the next translated element.  This is mostly useful to the texinfo module, as comments are automatically handled in TeX.
it: Aggiungi una stringa come commento da aggiungere accanto al prossimo elemento tradotto. Utile principalmente per il modulo texinfo, visto che in questo modo i commenti possono essere gestiti automaticamente in TeX.

note: type: textblock
en: Wrapper around Transtractor's translate, with pre- and post-processing filters.
it: Wrapper attorno alla traduzione del Transtractor, con filtri pre- e post-elaborazione.

note: type: textblock
en: Comments of a paragraph are inserted as a PO comment for the first translated string of this paragraph.
it: I commenti di un paragrafo vengono inseriti come commenti PO per la prima stringa tradotta di questo paragrafo.

note: type: textblock
en: This function returns:
it: Questa funzione restituisce:

note: type: =item
en: A command name
it: Un nome comando

note: type: textblock
en: If no command is found at the beginning of the given buffer, this string will be empty.  Only commands that can be separated are considered.  The %separated_command hash contains the list of these commands.
it: Se non si trova il comando all'inizio del buffer dato, questa stringa sarà vuota.  Vengono tenuti in considerazione solo comandi che possono essere separati.  L'hash %separated_command contiene l'elenco di questi comandi.

note: type: =item
en: A variant
it: Una variante

note: type: textblock
en: This indicates if a variant is used.  For example, an asterisk (*) can be added at the end of sections command to specify that they should not be numbered.  In this case, this field will contain "*".  If there is no variant, the field is an empty string.
it: Indica se viene utilizzata una variante. Ad esempio, è possibile aggiungere un asterisco (*) alla fine del comando delle sezioni per specificare che non devono essere numerate. In questo caso, questo campo conterrà "*". Se non ci sono varianti, il campo è una stringa vuota.

note: type: =item
en: An array of tuples (type of argument, argument)
it: Un'array di tuple (tipo di argomento, argomento)

note: type: textblock
en: The type of argument can be either '{' (for mandatory arguments) or '[' (for optional arguments).
it: Il tipo di argomento può essere '{' (per argomenti obbligatori) o '[' (per argomenti facoltativi).

note: type: =item
en: The remaining buffer
it: Il buffer rimanente

note: type: textblock
en: The rest of the buffer after the removal of this leading command and its arguments.  If no command is found, the original buffer is not touched and returned in this field.
it: Il resto del buffer dopo la rimozione di questo comando principale e dei suoi argomenti. Se non viene trovato alcun comando, il buffer originale non viene toccato e restituito in questo campo.

note: type: textblock
en: The same as B<get_leading_command>, but for commands at the end of a buffer.
it: Come B<get_leading_command>, ma per comandi alla fine di un buffer.

note: type: textblock
en: Recursively translate a buffer by separating leading and trailing commands (those which should be translated separately) from the buffer.
it: Tradurre ricorsivamente un buffer separando i comandi iniziali e finali (quelli che dovrebbero essere tradotti separatamente) dal buffer.

note: type: textblock
en: If a function is defined in %translate_buffer_env for the current environment, this function will be used to translate the buffer instead of translate_buffer().
it: Se viene definita una funzione in %translate_buffer_env per l'ambiente corrente, questa funzione verrà utilizzata per tradurre il buffer invece di translate_buffer().

note: type: textblock
en: Overloads Transtractor's read().
it: Fa l'overload della funzione read() di Transtractor.

note: type: textblock
en: Recursively read a file, appending included files which are not listed in the @exclude_include array.  Included files are searched using the B<kpsewhich> command from the Kpathsea library.
it: Legge ricorsivamente un file, aggiungendo i file inclusi che non siano elencati nell'array @exclude_include. I file inclusi vengono cercati usando il comando B<kpsewhich> dalla libreria Kpathsea.

note: type: textblock
en: Except from the file inclusion part, it is a cut and paste from Transtractor's read.
it: Fatta eccezione per la parte di inclusione del file, è un taglia e incolla della funzione read di Transtractor.

note: type: textblock
en: Subroutine for parsing a file with po4a directives (definitions for new commands).
it: Subroutine per l'analisi di un file con direttive po4a (definizioni per nuovi comandi).

note: type: textblock
en: Parse a definition line of the form "% po4a: ".
it: Elabora una riga di definizione nella forma "% po4a: ".

note: type: textblock
en: See the B<INLINE CUSTOMIZATION> section for more details.
it: Consultare la sezione B<PERSONALIZZAZIONE INLINE> per ulteriori dettagli.

note: type: =head1
en: INTERNAL FUNCTIONS used to write derivative parsers
it: FUNZIONI INTERNE usate per scrivere parser derivati

note: type: textblock
en: Command and environment functions take the following arguments (in addition to the $self object):
it: Comando e funzioni ambiente prendono i seguenti argomenti (oltre all'oggetto $self):

note: type: =item
en: An array of (type, argument) tuples
it: Un array di tuple (tipo, argomento)

note: type: =item
en: The current environment
it: L'ambiente corrente

note: type: textblock
en: The first 3 arguments are extracted by get_leading_command or get_trailing_command.
it: I primi 3 argomenti vengono estratti da get_leading_command o get_trailing_command.

note: type: textblock
en: Command and environment functions return the translation of the command with its arguments and a new environment.
it: Comando e funzioni ambiente restituiscono la traduzione del comando con i suoi argomenti e un nuovo ambiente.

note: type: textblock
en: Environment functions are called when a \begin command is found. They are called with the \begin command and its arguments.
it: Le funzioni ambiente vengono chiamate quando viene trovato un comando \begin . Vengono chiamate con il comando \begin ed i suoi argomenti.

note: type: textblock
en: The TeX module only proposes one command function and one environment function: generic_command and generic_environment.
it: Il modulo TeX propone solo una funzione comando e una funzione ambiente: generic_command e generic_environment.

note: type: verbatim
en: generic_command uses the information specified by
    register_generic_command or by adding definition to the TeX file:
     % po4a: command I<command1> I<parameters>
it: generic_command usa le informazioni specificate by
    register_generic_command o aggiungendo una definizione al file TeX:
     % po4a: command I<comando1> I<parametri>

note: type: verbatim
en: generic_environment uses the information specified by
    register_generic_environment or by adding definition to the TeX file:
     % po4a: environment I<env> I<parameters>
it: generic_environment usa le informazioni specificate da
    register_generic_environment o aggiungendo una definizione al file TeX:
     % po4a: environment I<ambiente> I<parametri>

note: type: textblock
en: Both functions will only translate the parameters that were specified as translatable (with a '_').  generic_environment will append the name of the environment to the environment stack and generic_command will append the name of the command followed by an identifier of the parameter (like {#7} or [#2]).
it: Entrambe le funzioni tradurranno solo i parametri che sono stati specificati come traducibili (con un '_'). generic_environment aggiungerà il nome dell'ambiente allo stack dell'ambiente e generic_command aggiungerà il nome del comando seguito da un identificatore del parametro (come {#7} o [#2]).

note: type: textblock
en: This module needs more tests.
it: Questo modulo necessita di più controlli.

note: type: textblock
en: It was tested on a book and with the Python documentation.
it: È stato testato su un libro e con la documentazione Python.

note: type: =head1
en: TODO LIST
it: ELENCO DEI DAFARE

note: type: =item
en: Automatic detection of new commands
it: Rilevamento automatico di nuovi comandi

note: type: textblock
en: The TeX module could parse the newcommand arguments and try to guess the number of arguments, their type and whether or not they should be translated.
it: Il modulo TeX potrebbe analizzare gli argomenti del nuovo comando e provare a indovinare il numero di argomenti, il loro tipo e se devono essere tradotti o meno.

note: type: =item
en: Translation of the environment separator
it: Traduzione del separatore d'ambiente

note: type: textblock
en: When \item is used as an environment separator, the item argument is attached to the following string.
it: Quando \item è usato come separatore d'ambiente, l'argomento item è allegato alla stringa seguente.

note: type: =item
en: Some commands should be added to the environment stack
it: Alcuni comandi dovrebbero essere aggiunti alla pila dell'ambiente

note: type: textblock
en: These commands should be specified by couples.  This can be used to specify commands beginning or ending a verbatim environment.
it: Questi comandi dovrebbero essere specificati da coppie.  Ciò può essere usato per specificare i comandi che iniziano o terminano un ambiente letterale.

note: type: =item
en: Others
it: Altri

note: type: textblock
en: Various other points are tagged TODO in the source.
it: Vari altri punti sono marcato come TODO (DAFARE) nel sorgente.

note: type: =head1
en: KNOWN BUGS
it: BUG CONOSCIUTI

note: type: textblock
en: Various points are tagged FIXME in the source.
it: Vari punti sono marcati come FIXME (AGGIUSTAMI) nel sorgente.

note: type: textblock
en: Locale::Po4a::Texinfo - convert Texinfo documents and derivates from/to PO files
it: Locale::Po4a::Texinfo - converte documenti Texinfo e derivati da/a file PO

note: type: textblock
en: Locale::Po4a::Texinfo is a module to help the translation of Texinfo documents into other [human] languages.
it: Locale::Po4a::Texinfo è un modulo che aiuta la traduzione in altre lingue della documentazione in formato Texinfo.

note: type: textblock
en: This module contains the definitions of common Texinfo commands and environments.
it: Questo modulo contiene le definizioni dei comandi e degli ambienti comuni di Texinfo.

note: type: textblock
en: Only the comments starting with 'TRANSLATORS' are added to the PO files to guide the translators.
it: Solo i commenti che iniziano con "TRANSLATORS" vengono aggiunti ai file PO per guidare i traduttori.

note: type: textblock
en: Copyright © 2004-2007 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
it: Copyright © 2004-2007 by Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.

note: type: textblock
en: Locale::Po4a::Text - convert text documents from/to PO files
it: Locale::Po4a::Text - converte documenti di testo da/a file PO

note: type: textblock
en: Locale::Po4a::Text is a module to help the translation of text documents into other [human] languages.
it: Locale::Po4a::Text è un modulo che aiuta la traduzione in altre lingue della documentazione in formato testo.

note: type: textblock
en: Paragraphs are split on empty lines (or lines containing only spaces or tabulations).
it: I paragrafi sono divisi su righe vuote (o righe contenenti solo spazi o tabulazioni).

note: type: textblock
en: If a paragraph contains a line starting by a space (or tabulation), this paragraph won't be rewrapped.
it: Se un paragrafo contiene una riga che inizia con uno spazio (o tabulazione), questo paragrafo non verrà riformattato.

note: type: textblock
en: Treat paragraphs that look like a key value pair as verbatim (with the no-wrap flag in the PO file).  Key value pairs are defined as a line containing one or more non-colon and non-space characters followed by a colon followed by at least one non-space character before the end of the line.
it: Tratta i paragrafi che sembrano una coppia chiave-valore come letterali (con il flag no-wrap nel file PO). Le coppie chiave-valore sono definite come una riga contenente uno o più caratteri non due punti e non spazio seguiti da due punti seguiti da almeno un carattere non spazio prima del fine riga.

note: type: textblock
en: Deactivate the detection of bullets.
it: Disattiva il rilevamento elenco puntato.

note: type: textblock
en: By default, when a bullet is detected, the bullet paragraph is not considered as a verbatim paragraph (with the no-wrap flag in the PO file). Instead, the corresponding paragraph is rewrapped in the translation.
it: Per impostazione predefinita, quando viene rilevato un elenco puntato, il paragrafo non viene considerato come un paragrafo letterale (con il flag no-wrap nel file PO). Invece, il paragrafo corrispondente viene riformattato nella traduzione.

note: type: =item
en: B<tabs=>I<mode>
it: B<tabs=>I<modalità>

note: type: textblock
en: Specify how tabulations shall be handled. The I<mode> can be any of:
it: Specifica come devono essere gestite le tabulazioni. La I<modalità> può essere una qualsiasi di:

note: type: textblock
en: Lines with tabulations introduce breaks in the current paragraph.
it: Le righe con tabulazioni introducono interruzioni nel paragrafo corrente.

note: type: textblock
en: Paragraph containing tabulations will not be re-wrapped.
it: I paragrafi contenenti tabulazioni non verranno riformattati.

note: type: textblock
en: By default, tabulations are considered as spaces.
it: Per impostazione predefinita, le tabulazioni sono considerate come spazi.

note: type: textblock
en: A regular expression matching lines which introduce breaks.  The regular expression will be anchored so that the whole line must match.
it: Un'espressione regolare che corrisponde a righe che introducono interruzioni. L'espressione regolare verrà ancorata in modo che l'intera riga corrisponda.

note: type: textblock
en: Handle the header and footer of released versions, which only contain non translatable information.
it: Gestisce l'intestazione e il piè di pagina delle versioni rilasciate, che contengono solo informazioni non traducibili.

note: type: textblock
en: Handle the fortunes format, which separate fortunes with a line which consists in '%' or '%%', and use '%%' as the beginning of a comment.
it: Gestisci il formato fortune, che separa le frasi fortune con una linea che consiste in '%' o '%%', e usa '%%' come inizio di un commento.

note: type: textblock
en: Handle some special markup in Markdown-formatted texts.
it: Gestisci alcuni markup speciali nei testi formattati per Markdown.

note: type: =item
en: B<yfm_keys> (markdown-only)
it: B<yfm_keys> (solo-markdown)

note: type: =item
en: B<yfm_lenient> (markdown only)
it: B<yfm_lenient> (solo-markdown)

note: type: textblock
en: Allow the YAML Front Matter parser to fail on malformated headers. This is particularly helpful when your file starts with a horizontal ruler instead of a YAML Front Matter, but you insist on using three dashes only for your ruler.
it: Permette l'analizzatore YAML Front Matter di fallire con intestazioni malformate. Ciò è particolarmente utile quando il file comincia con un separatore orizzontale invece di un YAML Front Matter, ma si insiste ad usare tre lineette solo per il proprio separatore.

note: type: =item
en: B<yfm_paths> (markdown only)
it: B<yfm_paths> (solo markdown)

note: type: =item
en: B<yfm_skip_array> (markdown-only)
it: B<yfm_skip_array> (solo-markdown)

note: type: =item
en: B<control>[B<=>I<taglist>]
it: B<control>[B<=>I<elencotag>]

note: type: textblock
en: Handle control files.  A comma-separated list of tags to be translated can be provided.
it: Gestisci i file di controllo. È possibile fornire un elenco separato da virgole di tag da tradurre.

note: type: textblock
en: Prevent po4a from wrapping any lines. This means that every content is handled verbatim, even simple paragraphs.
it: Impedisci a po4a di formattare le righe. Ciò significa che ogni contenuto viene gestito alla lettera, anche i paragrafi semplici.

note: type: textblock
en: Tested successfully on simple text files and NEWS.Debian files.
it: Testato con successo su semplici file di testo e file NEWS.Debian.

note: type: textblock
en: Locale::Po4a::TransTractor - generic trans(lator ex)tractor.
it: Locale::Po4a::TransTractor - Modulo generico di traduzione ed estrazione del testo

note: type: textblock
en: This class is the ancestor of every po4a parser used to parse a document, to search translatable strings, to extract them to a PO file and to replace them by their translation in the output document.
it: Questa classe è l'antenato di ogni parser po4a usato per analizzare un documento, per cercare stringhe traducibili, per estrarle in un file PO e per sostituirle con la loro traduzione nel documento in uscita.

note: type: textblock
en: More formally, it takes the following arguments as input:
it: Più formalmente, prende i seguenti argomenti in ingresso:

note: type: textblock
en: a document to translate;
it: un documento da tradurre;

note: type: textblock
en: a PO file containing the translations to use.
it: un file PO contenente le traduzioni da usare.

note: type: textblock
en: As output, it produces:
it: In uscita, produce:

note: type: textblock
en: another PO file, resulting of the extraction of translatable strings from the input document;
it: un altro file PC, risultante dall'estrazione delle stringe traducibili dal documento in ingresso;

note: type: textblock
en: a translated document, with the same structure than the one in input, but with all translatable strings replaced with the translations found in the PO file provided in input.
it: un documento tradotto, con la stessa struttura di quello in ingresso, ma con tutte le stringhe traducibili sostituite con le traduzioni trovate nel file PO fornito in ingresso.

note: type: textblock
en: Here is a graphical representation of this:
it: Ecco una rappresentazione grafica di ciò:

note: type: verbatim
en:    Input document --\                             /---> Output document
                         \                           /       (translated)
                          +-> parse() function -----+
                         /                           \
       Input PO --------/                             \---> Output PO
                                                             (extracted)
it:  Documento in ingresso -\                          /--> Documento in uscita
                             \                        /         (tradotto)
                              +-> funzione parse() --+
                             /                        \
      PO in ingresso -------/                          \--> PO in uscita
                                                              (estratto)

note: type: =head1
en: FUNCTIONS YOUR PARSER SHOULD OVERRIDE
it: FUNZIONI CHE IL PROPRIO PARSER DOVREBBE RIDEFINIRE

note: type: textblock
en: This is where all the work takes place: the parsing of input documents, the generation of output, and the extraction of the translatable strings. This is pretty simple using the provided functions presented in the section B<INTERNAL FUNCTIONS> below. See also the B<SYNOPSIS>, which presents an example.
it: È qui che si svolge tutto il lavoro: l'analisi dei documenti di ingresso, la generazione del risultato in uscita e l'estrazione delle stringhe traducibili. Tutto ciò è abbastanza semplice facendo uso delle funzioni presentate nella sezione B<FUNZIONI INTERNE> di seguito. Vedere anche B<SINTASSI>, che presenta un esempio.

note: type: textblock
en: This function is called by the process() function below, but if you choose to use the new() function, and to add content manually to your document, you will have to call this function yourself.
it: Questa funzione viene chiamata dalla funzione process() di seguito, ma se si sceglie di usare la funzione new() e di aggiungere contenuto manualmente al documento, si dovrà chiamare questa funzione.

note: type: textblock
en: This function returns the header we should add to the produced document, quoted properly to be a comment in the target language.  See the section B<Educating developers about translations>, from L<po4a(7)|po4a.7>, for what it is good for.
it: Questa funzione restituisce l'intestazione che dovremmo aggiungere al documento prodotto, quotata opportunamente tanto da essere considerata un commento nella lingua di destinazione. Vedere la sezione B<Educare gli sviluppatori sulle traduzioni>, da L<po4a(7)|po4a.7>, per sapere a cosa serve.

note: type: textblock
en: The following example parses a list of paragraphs beginning with "<p>". For the sake of simplicity, we assume that the document is well formatted, i.e. that '<p>' tags are the only tags present, and that this tag is at the very beginning of each paragraph.
it: L'esempio seguente analizza un elenco di paragrafi che iniziano con "<p>". Per semplicità, assumiamo che il documento sia ben formattato, ovvero che i tag '<p>' siano gli unici tag presenti e che questo tag sia all'inizio di ogni paragrafo.

note: type: verbatim
en:    PARAGRAPH: while (1) {
           my ($paragraph,$pararef)=("","");
           my $first=1;
           my ($line,$lref)=$self->shiftline();
           while (defined($line)) {
               if ($line =~ m/<p>/ && !$first--; ) {
                   # Not the first time we see <p>.
                   # Reput the current line in input,
                   #  and put the built paragraph to output
                   $self->unshiftline($line,$lref);
it:    PARAGRAPH: while (1) {
           my ($paragraph,$pararef)=("","");
           my $first=1;
           my ($line,$lref)=$self->shiftline();
           while (defined($line)) {
               if ($line =~ m/<p>/ && !$first--; ) {
                   # Non la prima volta che si vede <p>.
                   # Rimette la riga corrente in ingresso,
                   #  e mette il paragrafo costruito in uscita
                   $self->unshiftline($line,$lref);

note: type: verbatim
en:                # Now that the document is formed, translate it:
                   #   - Remove the leading tag
                   $paragraph =~ s/^<p>//s;
it:                # Ora che il documento è formato, lo traduce:
                   #   - Rimuove il tag d'inzio
                   $paragraph =~ s/^<p>//s;

note: type: verbatim
en:                #   - push to output the leading tag (untranslated) and the
                   #     rest of the paragraph (translated)
                   $self->pushline(  "<p>"
                                   . $self->translate($paragraph,$pararef)
                                   );
it:                #   - inserisce in uscita il tag iniziale (non tradotto) e
                   #     il resto del paragrafo (tradotto)
                   $self->pushline(  "<p>"
                                   . $self->translate($paragraph,$pararef)
                                   );

note: type: verbatim
en:                next PARAGRAPH;
               } else {
                   # Append to the paragraph
                   $paragraph .= $line;
                   $pararef = $lref unless(length($pararef));
               }
it:                next PARAGRAPH;
               } else {
                   # Accoda al paragrafo
                   $paragraph .= $line;
                   $pararef = $lref unless(length($pararef));
               }

note: type: verbatim
en:            # Reinit the loop
               ($line,$lref)=$self->shiftline();
           }
           # Did not get a defined line? End of input file.
           return;
       }
     }
it:            # Reinizializza il ciclo
               ($line,$lref)=$self->shiftline();
           }
           # Nessuna una riga definita? Fine file in ingresso.
           return;
       }
     }

note: type: textblock
en: Once you've implemented the parse function, you can use your document class, using the public interface presented in the next section.
it: Una volta implementata la funzione di analisi, si può usare la propria classe documento, usando l'interfaccia pubblica presentata nella sezione successiva.

note: type: =head1
en: PUBLIC INTERFACE for scripts using your parser
it: INTERFACCIA PUBBLICA per gli script che usano il proprio parser

note: type: =head2
en: Constructor
it: Costruttore

note: type: =item
en: process(%)
it: processo(%)

note: type: textblock
en: This function can do all you need to do with a po4a document in one invocation. Its arguments must be packed as a hash. ACTIONS:
it: Questa funzione può fare tutto quello che si deve fare con un documento po4a in una sola chiamata. I suoi argomenti devono essere impacchettati come un hash. AZIONI:

note: type: textblock
en: Reads all the PO files specified in po_in_name
it: Legge tutti i file PO specificati in po_in_name

note: type: textblock
en: Reads all original documents specified in file_in_name
it: Legge tutti i documenti originali specificati in file_in_name

note: type: textblock
en: Parses the document
it: Analizza il documento

note: type: textblock
en: Reads and applies all the addenda specified
it: Legge e applica tutte le addenda specificate

note: type: textblock
en: Writes the translated document to file_out_name (if given)
it: Scrive il documento tradotto in file_out_name (se fornito)

note: type: textblock
en: Writes the extracted PO file to po_out_name (if given)
it: Scrive il file PO estratto in po_out_name (se fornito)

note: type: textblock
en: ARGUMENTS, beside the ones accepted by new() (with expected type):
it: ARGOMENTI, oltre a quelli accettati da new() (di tipo atteso):

note: type: textblock
en: List of filenames where we should read the input document.
it: Elenco di nomi di file in cui si dovrebbe leggere il documento di ingresso.

note: type: textblock
en: Charset used in the input document (if it isn't specified, it will try to detect it from the input document).
it: Set di caratteri utilizzato nel documento di ingresso (se non è specificato, proverà a rilevarlo dal documento di ingresso).

note: type: textblock
en: Filename where we should write the output document.
it: Nome file dove si dovrà scrivere il documento di uscita.

note: type: textblock
en: Charset used in the output document (if it isn't specified, it will use the PO file charset).
it: Set di caratteri usato nel documento in uscita (se non è specificato, userà il set di caratteri del file PO).

note: type: textblock
en: List of filenames where we should read the input PO files from, containing the translation which will be used to translate the document.
it: Elenco di nomi di file da cui leggere i file PO in ingresso, contenente la traduzione che verrà usata per tradurre il documento.

note: type: textblock
en: Filename where we should write the output PO file, containing the strings extracted from the input document.
it: Nome file dove si dovrà scrivere il file PO in uscita, contenente le stringhe estratte dal documento in ingresso.

note: type: textblock
en: List of filenames where we should read the addenda from.
it: Elenco di nomi di file da cui si dovrà leggere le addenda.

note: type: textblock
en: Charset for the addenda.
it: Set di caratteri delle addenda.

note: type: textblock
en: Create a new po4a document. Accepted options (in the hash passed as a parameter):
it: Crea un nuovo documento po4a. Opzioni accettate (nell'hash passato come parametro):

note: type: textblock
en: Sets the verbosity.
it: Imposta il livello di messaggi diagnostici.

note: type: textblock
en: Sets the debugging.
it: Imposta il debug.

note: type: =head2
en: Manipulating document files
it: Gestione file dei documenti

note: type: textblock
en: Add another input document data at the end of the existing array C<< @{$self->{TT}{doc_in}} >>. The argument is the filename to read. If a second argument is provided, it is the filename to use in the references.
it: Aggiunge un altro dato del documento di input alla fine dell'array esistente C<< @{$self->{TT}{doc_in}} >>. L'argomento è il nome del file da leggere. Se viene fornito un secondo argomento, è il nome del file da utilizzare nei riferimenti.

note: type: verbatim
en: This array C<< @{$self->{TT}{doc_in}} >> holds this input document data as an
    array of strings with alternating meanings.
     * The string C<$textline> holding each line of the input text data.
     * The string C<< $filename:$linenum >> holding its location and called as
       "reference" (C<linenum> starts with 1).
it: Questo array C<< @{$self->{TT}{doc_in}} >> contiene i dati di questo documento
    di ingresso come array di stringhe con significati alternati.
      * La stringa C<$textline> contenente ogni riga dei dati di testo di ingresso.
      * La stringa C<< $filename:$linenum >> contenente la sua posizione viene
        chiamata come "riferimento" (C<linenum> inizia con 1).

note: type: textblock
en: Please note that it does not parse anything. You should use the parse()  function when you're done with packing input files into the document.
it: Si noti che non analizza nulla. Si dovrebbe usare la funzione parse() quando si ha finito di impacchettare i file in ingresso nel documento.

note: type: textblock
en: Write the translated document to the given filename.
it: Scrive il documento tradotto con il nome file specificato.

note: type: verbatim
en: This translated document data are provided by:
     * C<< $self->docheader() >> holding the header text for the plugin, and
     * C<< @{$self->{TT}{doc_out}} >> holding each line of the main translated text in the array.
it: I dati di questo documento tradotto sono forniti da:
      * C<< $self->docheader() >> che contiene il testo dell'intestazione per il plugin, e
      * C<< @{$self->{TT}{doc_out}} >> che contiene ogni riga del testo tradotto principale nell'array.

note: type: =head2
en: Manipulating PO files
it: Gestione file PO

note: type: textblock
en: Add the content of a file (which name is passed as argument) to the existing input PO. The old content is not discarded.
it: Aggiunge il contenuto di un file (il cui nome viene passato come argomento) al PO di ingresso esistente. Il vecchio contenuto non viene scartato.

note: type: textblock
en: Write the extracted PO file to the given filename.
it: Scrive il file PO estratto nel nome file dato.

note: type: textblock
en: Returns some statistics about the translation done so far. Please note that it's not the same statistics than the one printed by msgfmt --statistic. Here, it's stats about recent usage of the PO file, while msgfmt reports the status of the file. It is a wrapper to the Locale::Po4a::Po::stats_get function applied to the input PO file. Example of use:
it: Restituisce alcune statistiche sulla traduzione eseguita fino a quel momento. Si noti che non sono le stesse statistiche di quelle prodotte dal comando da msgfmt --statistic. Qui, sono le statistiche sull'utilizzo recente del file PO, mentre msgfmt riporta lo stato del file. È un wrapper per la funzione Locale::Po4a::Po::stats_get applicata al file PO di ingresso. Esempio d'uso:

note: type: verbatim
en:     [normal use of the po4a document...]
it:     [uso normale del documento po4a...]

note: type: verbatim
en:     ($percent,$hit,$queries) = $document->stats();
        print "We found translations for $percent\%  ($hit from $queries) of strings.\n";
it:     ($percent,$hit,$queries) = $document->stats();
        print "Trovate traduzioni for $percent\%  ($hit da $queries) di stringhe.\n";

note: type: =head2
en: Manipulating addenda
it: Gestione addenda

note: type: textblock
en: Please refer to L<po4a(7)|po4a.7> for more information on what addenda are, and how translators should write them. To apply an addendum to the translated document, simply pass its filename to this function and you are done ;)
it: Fare riferimento a L<po4a(7)|po4a.7> per maggiori informazioni su cosa sono gli addenda e su come i traduttori dovrebbero scriverli. Per applicare un addendum al documento tradotto, passare semplicemente il suo nome file a questa funzione ed il gioco è fatto ;)

note: type: textblock
en: This function returns a non-null integer on error.
it: Questa funzione restituisce un intero non nullo in caso di errore.

note: type: =head2
en: Getting input, providing output
it: Ottenere l'ingresso, fornire l'uscita

note: type: textblock
en: Four functions are provided to get input and return output. They are very similar to shift/unshift and push/pop of Perl.
it: Vengono fornite quattro funzioni per catturare l'ingresso e restituire l'uscita. Sono molto simili a shift/unshift e push/pop di Perl.

note: type: verbatim
en:  * Perl shift returns the first array item and drop it from the array.
     * Perl unshift prepends an item to the array as the first array item.
     * Perl pop returns the last array item and drop it from the array.
     * Perl push appends an item to the array as the last array item.
it:  * Perl shift restituisce il primo elemento dell'array e lo toglie dall'array.
     * Perl unshift antepone un elemento all'array come primo elemento dell'array.
     * Perl pop restituisce l'ultimo elemento dell'array e lo toglie dall'array.
     * Perl push aggiunge un elemento all'array come ultimo elemento dell'array.

note: type: textblock
en: The first pair is about input, while the second is about output. Mnemonic: in input, you are interested in the first line, what shift gives, and in output you want to add your result at the end, like push does.
it: La prima coppia riguarda l'ingresso, mentre la seconda riguarda l'uscita. Mnemonico: in ingresso, si è interessati alla prima riga, cosa dà shift, e in uscita si desidera aggiungere il risultato alla fine, come fa push.

note: type: textblock
en: This function returns the first line to be parsed and its corresponding reference (packed as an array) from the array C<< @{$self->{TT}{doc_in}} >> and drop these first 2 array items.  Here, the reference is provided by a string C<< $filename:$linenum >>.
it: Questa funzione restituisce la prima riga da analizzare e il suo riferimento corrispondente (compresso come un array) dall'array C<< @{$self->{TT}{doc_in}} >> e rilascia questi primi 2 elementi dell'array. Qui, il riferimento è fornito da una stringa C<< $filename:$linenum >>.

note: type: textblock
en: Unshifts the last shifted line of the input document and its corresponding reference back to the head of C<< {$self->{TT}{doc_in}} >>.
it: Annulla lo spostamento dell'ultima riga spostata del documento in ingresso e il relativo riferimento corrispondente all'inizio di C<< {$self->{TT}{doc_in}} >>.

note: type: textblock
en: Push a new line to the end of C<< {$self->{TT}{doc_out}} >>.
it: Inserisce una nuova riga alla fine di C<< {$self->{TT}{doc_out}} >>.

note: type: textblock
en: Pop the last pushed line from the end of C<< {$self->{TT}{doc_out}} >>.
it: Estrae l'ultima riga inserita dalla fine di C<< {$self->{TT}{doc_out}} >>.

note: type: =head2
en: Marking strings as translatable
it: Marcatura stringhe come traducibili

note: type: textblock
en: One function is provided to handle the text which should be translated.
it: Viene fornita una funzione per gestire il testo da tradurre.

note: type: textblock
en: Mandatory arguments:
it: Argomenti obbligatori:

note: type: textblock
en: A string to translate
it: Una stringa da tradurre

note: type: textblock
en: The reference of this string (i.e. position in inputfile)
it: Il riferimento di questa stringa (cioè la posizione nel file di ingresso)

note: type: textblock
en: The type of this string (i.e. the textual description of its structural role; used in Locale::Po4a::Po::gettextization(); see also L<po4a(7)|po4a.7>, section B<Gettextization: how does it work?>)
it: Il tipo di questa stringa (cioè la descrizione testuale del suo ruolo strutturale; usata in Locale::Po4a::Po::gettextization(); vedere anche L<po4a(7)|po4a.7>, sezione B<Gettext-izzazione: come funziona?>)

note: type: textblock
en: This function can also take some extra arguments. They must be organized as a hash. For example:
it: Anche questa funzione usa alcuni argomenti extra. Questi devono essere organizzati come hash. Esempio:

note: type: textblock
en: boolean indicating whether we can consider that whitespaces in string are not important. If yes, the function canonizes the string before looking for a translation or extracting it, and wraps the translation.
it: booleano indicande se si può considerare gli spazi bianchi nella stringa come non importanti. Se si, la funzione canonizza la stringa prima di cercare una traduzione o estrarla, e formatta la traduzione.

note: type: textblock
en: an extra comment to add to the entry.
it: un commento extra da aggiungere alla voce.

note: type: textblock
en: Actions:
it: Azioni:

note: type: textblock
en: Pushes the string, reference and type to po_out.
it: Infila stringa, riferimento e tipo in po_out.

note: type: textblock
en: Returns the translation of the string (as found in po_in) so that the parser can build the doc_out.
it: Restituisce la traduzione della stringa (come trovata in po_in) in modo che l'analizzatore possa creare doc_out.

note: type: textblock
en: Handles the charsets to recode the strings before sending them to po_out and before returning the translations.
it: Gestisce i set di caratteri per ricodificare le stringhe prima di inviarle a po_out e prima di restituire le traduzioni.

note: type: =head2
en: Misc functions
it: Funzioni varie

note: type: textblock
en: Returns if the verbose option was passed during the creation of the TransTractor.
it: Restituisce se l'opzione verbose è stata passata durante la creazione di TransTractor.

note: type: textblock
en: Returns if the debug option was passed during the creation of the TransTractor.
it: Restituisce se l'opzione di debug è stata passata durante la creazione di TransTractor.

note: type: textblock
en: This tells TransTractor that a new charset (the first argument) has been detected from the input document. It can usually be read from the document header. Only the first charset will remain, coming either from the process() arguments or detected from the document.
it: Questo dice a TransTractor che un nuovo set di caratteri (il primo argomento) è stato rilevato dal documento in ingresso. Di solito può essere letto dall'intestazione del documento. Rimarrà solo il primo set di caratteri, proveniente dagli argomenti process() o rilevato dal documento.

note: type: textblock
en: This function will return the charset that should be used in the output document (usually useful to substitute the input document's detected charset where it has been found).
it: Questa funzione restituirà il set di caratteri che dovrebbe essere utilizzato nel documento in uscita (solitamente utile per sostituire il set di caratteri rilevato del documento in ingresso dove è stato trovato).

note: type: textblock
en: It will use the output charset specified in the command line. If it wasn't specified, it will use the input PO's charset, and if the input PO has the default "CHARSET", it will return the input document's charset, so that no encoding is performed.
it: Userà il set di caratteri in uscita specificato nella riga di comando. Se non è stato specificato, userà il set di caratteri del PO in ingresso e se il PO in ingresso ha il "CHARSET" predefinito, restituirà il set di caratteri del documento in ingresso, in modo che non venga eseguita alcuna codifica.

note: type: textblock
en: This function returns the recoded text passed as argument, from the input document's charset to the output document's one. This isn't needed when translating a string (translate() recodes everything itself), but it is when you skip a string from the input document and you want the output document to be consistent with the global encoding.
it: Questa funzione restituisce il testo ricodificato passato come argomento, dal set di caratteri del documento in ingresso a quello del documento in uscita. Non è indispensabile quando si traduce una stringa (dato che translate() ricodifica tutto da solo), ma è necessario quando si salta una stringa dal documento in ingresso e si desidera che il documento in uscita sia coerente con la codifica globale.

note: type: =head1
en: FUTURE DIRECTIONS
it: DIREZIONI FUTURE

note: type: textblock
en: One shortcoming of the current TransTractor is that it can't handle translated document containing all languages, like debconf templates, or .desktop files.
it: Un difetto dell'attuale TransTractor è che non può gestire documenti tradotti contenenti tutte le lingue, come modelli debconf o file .desktop.

note: type: textblock
en: To address this problem, the only interface changes needed are:
it: Per risolvere questo problema, le uniche modifiche all'interfaccia necessarie sono:

note: type: textblock
en: take a hash as po_in_name (a list per language)
it: prendere un hash come po_in_name (un elenco per lingua)

note: type: textblock
en: add an argument to translate to indicate the target language
it: aggiungere un argomento da tradurre per indicare la lingua di destinazione

note: type: textblock
en: make a pushline_all function, which would make pushline of its content for all languages, using a map-like syntax:
it: crea una funzione pushline_all, fa in modo di eseguire una pushline del suo contenuto per tutte le lingue, utilizzando una sintassi simile a una mappa:

note: type: textblock
en: Will see if it's enough ;)
it: Vedremo se è abbastanza ;)

note: type: textblock
en: Locale::Po4a::Wml - convert WML (web markup language) documents from/to PO files
it: Locale::Po4a::Wml - converte documenti WML (Web Markup Language) da/verso file PO

note: type: textblock
en: Locale::Po4a::Wml is a module to help the translation of WML documents into other [human] languages. Do not mixup the WML we are speaking about here (web markup language) and the WAP crap used on cell phones.
it: Locale::Po4a::Wml è un modulo che aiuta la traduzione in altre lingue della documentazione in formato WML. Non si confonda il WML di cui stiamo parlando (Web Markup Language) con la schifezza WAP usata sui cellulari.

note: type: textblock
en: Please note that this module relies upon the Locale::Po4a::Xhtml module, which also relies upon the Locale::Po4a::Xml module.  This means that all tags for web page expressions are assumed to be written in the XHTML syntax.
it: Si noti che questo modulo si basa sul modulo Locale::Po4a::Xhtml, che si basa anche sul modulo Locale::Po4a::Xml. Ciò significa che si presume che tutti i tag per le espressioni delle pagine Web siano scritti nella sintassi XHTML.

note: type: textblock
en: This module works for some simple documents, but is still young.  Currently, the biggest issue of the module is probably that it cannot handle documents that contain non-XML inline tags such as <email "foo@example.org">, which are often defined in the WML.  Improvements will be added in the future releases.
it: Questo modulo funziona per alcuni documenti semplici, ma è ancora giovane. Attualmente, il problema più grande del modulo è probabilmente che non può gestire documenti che contengono tag in linea non XML come <email "foo@example.org">, che sono spesso definiti nel WML. Miglioramenti verranno aggiunti in versioni future.

note: type: verbatim
en:  Copyright © 2005 SPI, Inc.
it:  Copyright © 2005 by SPI, inc.

note: type: textblock
en: Locale::Po4a::Xhtml - convert XHTML documents from/to PO files
it: Locale::Po4a::Xhtml - converte documenti XHTML da/a file PO

note: type: textblock
en: Locale::Po4a::Xhtml is a module to help the translation of XHTML documents into other [human] languages.
it: Locale::Po4a::Xhtml è un modulo che aiuta la traduzione in altre lingue della documentazione in formato XHTML.

note: type: textblock
en: Include files specified by an include SSI (Server Side Includes) element (e.g. <!--#include virtual="/foo/bar.html" -->).
it: Include i file specificati da un elemento include SSI (Server Side Include) (es. <!--#include virtual="/foo/bar.html" -->).

note: type: textblock
en: B<Note:> You should use it only for static files.
it: B<Note:> Da usare solo per file statici.

note: type: textblock
en: An additional I<rootpath> parameter can be specified. It specifies the root path to find files included by a B<virtual> attribute.
it: È possibile specificare un parametro I<rootpath> aggiuntivo. Specifica il percorso radice per trovare i file inclusi da un attributo B<virtuale>.

note: type: textblock
en: "It works for me", which means I use it successfully on my personal Web site.  However, YMMV: please let me know if something doesn't work for you.
it: "A me funziona", significa che viene usato con successo sul sito Web personale di uno degli sviluppatori. Tuttavia, YMMV: per favore fateci sapere se qualcosa non funziona.

note: type: verbatim
en:  Copyright © 2004 Yves Rütschlé <po4a@rutschle.net>
     Copyright © 2007-2008 Nicolas François <nicolas.francois@centraliens.net>
it:  Copyright © 2004 by Yves Rütschlé <po4a@rutschle.net>
     Copyright © 2007-2008 by Nicolas François <nicolas.francois@centraliens.net>

note: type: textblock
en: Locale::Po4a::Xml - convert XML documents and derivates from/to PO files
it: Locale::Po4a::Xml - converte documenti XML e derivati da/verso file PO

note: type: textblock
en: Locale::Po4a::Xml is a module to help the translation of XML documents into other [human] languages. It can also be used as a base to build modules for XML-based documents.
it: Locale::Po4a::Xml è un modulo che aiuta la traduzione in altre lingue della documentazione in formato XML. Può anche essere usato come base per scrivere moduli per documenti basati su XML.

note: type: =head1
en: TRANSLATING WITH PO4A::XML
it: TRADURRE CON PO4A::XML

note: type: textblock
en: This module can be used directly to handle generic XML documents.  This will extract all tag's content, and no attributes, since it's where the text is written in most XML based documents.
it: Questo modulo può essere utilizzato direttamente per gestire documenti XML generici. Estrarrà tutto il contenuto del tag e nessun attributo, poiché è lì che viene scritto il testo nella gran parte dei documenti basati su XML.

note: type: textblock
en: There are some options (described in the next section) that can customize this behavior.  If this doesn't fit to your document format you're encouraged to write your own module derived from this, to describe your format's details.  See the section B<WRITING DERIVATE MODULES> below, for the process description.
it: Ci sono alcune opzioni (descritte nella sezione successiva) che possono personalizzare questo comportamento.  Se questo non dovesse adattarsi sufficientemente al formato del proprio documento si incoraggia a scriverne uno per il proprio modulo derivandolo da questo, per descrivere i dettagli del proprio formato. Consultare la prossima sezione B<SCRIVERE MODULI DERIVATI> più sotto, per la descrizione del processo.

note: type: textblock
en: The global debug option causes this module to show the excluded strings, in order to see if it skips something important.
it: L'opzione di debug globale fa sì che questo modulo mostri le stringhe escluse, per vedere se salta qualcosa di importante.

note: type: textblock
en: Prevents it to strip the spaces around the extracted strings.
it: Previene la rimozione degli spazi attorno alle stringhe estratte.

note: type: textblock
en: Canonicalizes the string to translate, considering that whitespaces are not important, and wraps the translated document. This option can be overridden by custom tag options. See the B<translated> option below.
it: Canonizza la stringa da tradurre, considerando che gli spazi bianchi non siano importanti, e formatta il documento tradotto. Questa opzione può essere superata da opzioni tag personalizzate. Vedere l'opzione B<translated> sotto.

note: type: textblock
en: Attributes are wrapped by default. This option disables wrapping.
it: Gli attributi vengono formattati per impostazione predefinita. Questa opzione disabilita la formattazione.

note: type: textblock
en: It makes the tags and attributes searching to work in a case insensitive way.  If it's defined, it will treat E<lt>BooKE<gt>laNG and E<lt>BOOKE<gt>Lang as E<lt>bookE<gt>lang.
it: Fa in modo che la ricerca di tag e attributi funzioni senza distinzione tra maiuscole e minuscole. Se è definito, tratterà E<lt>BookE<gt>laNG ed E<lt>BOOKE<gt>Lang come E<lt>bookE<gt>lang.

note: type: textblock
en: Escape quotes in output strings.  Necessary, for example, for creating string resources for use by Android build tools.
it: Virgolette di escape nelle stringhe in uscita. Necessario, ad esempio, per creare risorse stringa da utilizzare con gli strumenti di build Android.

note: type: textblock
en: See also: https://developer.android.com/guide/topics/resources/string-resource.html
it: Vedere anche: https://developer.android.com/guide/topics/resources/string-resource.html

note: type: textblock
en: When defined, external entities are included in the generated (translated)  document, and for the extraction of strings.  If it's not defined, you will have to translate external entities separately as independent documents.
it: Se definite, le entità esterne verranno incluse nel documento generato (tradotto) e per l'estrazione delle stringhe. Se non è definito, si dovrà tradurre gli elementi esterni separatamente come documenti indipendenti.

note: type: textblock
en: This option defines the behavior of the module when it encounters invalid XML syntax (a closing tag which does not match the last opening tag).  It can take the following values:
it: Questa opzione definisce il comportamento del modulo quando incontra una sintassi XML non valida (un tag di chiusura che non corrisponde all'ultimo tag di apertura). Può assumere i seguenti valori:

note: type: textblock
en: This is the default value.  The module will exit with an error.
it: Questo è il valore predefinito. Il modulo uscirà con un errore.

note: type: textblock
en: The module will continue, and will issue a warning.
it: L'esecuzione del modulo continuerà, e genererà un avvertimento.

note: type: textblock
en: The module will continue without any warnings.
it: Il modulo continuerà senza alcun avvertimento.

note: type: textblock
en: Be careful when using this option.  It is generally recommended to fix the input file.
it: Attenzione a usare questa opzione.  Generalmente si raccomanda di sistemare il file in ingresso.

note: type: textblock
en: Note: This option is deprecated.
it: Nota: questa opzione è sconsigliata.

note: type: textblock
en: Extracts only the specified tags in the B<tags> option.  Otherwise, it will extract all the tags except the ones specified.
it: Estrae solo i tag specificati nell'opzione B<tags>. Altrimenti, estrarrà tutti i tag tranne quelli specificati.

note: type: textblock
en: String that will try to match with the first line of the document's doctype (if defined). If it doesn't, a warning will indicate that the document might be of a bad type.
it: Stringa di cui verrà verificata la corrispondenza con la prima riga del doctype del documento (se definito). Nel caso non corrisponda, un avviso indicherà che il documento potrebbe essere di tipo non valido.

note: type: textblock
en: String indicating the path (e.g. E<lt>bbbE<gt>E<lt>aaaE<gt>) of a tag where a lang="..." attribute shall be added. The language will be defined as the basename of the PO file without any .po extension.
it: Stringa indicante il percorso (es. E<lt>bbbE<gt>E<lt>aaaE<gt>) di un tag a cui deve essere aggiunto un attributo lang="...". La lingua sarà definita come il nome di base del file PO senza alcuna estensione .po.

note: type: textblock
en: Boolean indicating whether closing tags are optional (as in HTML). By default, missing closing tags raise an error handled according to B<ontagerror>.
it: Valore booleano indicante se i tag di chiusura sono facoltativi (come in HTML). Per impostazione predefinita, i tag di chiusura mancanti generano un errore gestito secondo B<ontagerror>.

note: type: textblock
en: Note: This option is deprecated.  You should use the B<translated> and B<untranslated> options instead.
it: Nota: questa opzione è sconsigliata. In alternativa si consiglia di usare le opzioni B<translated> e B<untranslated>.

note: type: textblock
en: Space-separated list of tags you want to translate or skip.  By default, the specified tags will be excluded, but if you use the "tagsonly" option, the specified tags will be the only ones included.  The tags must be in the form E<lt>aaaE<gt>, but you can join some (E<lt>bbbE<gt>E<lt>aaaE<gt>) to say that the content of the tag E<lt>aaaE<gt> will only be translated when it's into a E<lt>bbbE<gt> tag.
it: Elenco separato da spazi di tag che si vuole tradurre o saltare. Per impostazione predefinita, i tag specificati verranno esclusi, ma se si usa l'opzione "tagsonly", i tag specificati saranno gli unici inclusi. I tag devono essere nella forma E<lt>aaaE<gt>, ma si può unirne alcuni (E<lt>bbbE<gt>E<lt>aaaE<gt>) per dire che il contenuto del tag E<lt>aaaE<gt> verrà tradotto solo quando è in un tag E<lt>bbbE<gt>.

note: type: textblock
en: You can also specify some tag options by putting some characters in front of the tag hierarchy. For example, you can put I<w> (wrap) or I<W> (don't wrap)  to override the default behavior specified by the global B<wrap> option.
it: Si può anche specificare alcune opzioni di tag inserendo alcuni caratteri davanti alla gerarchia dei tag. Ad esempio, si può inserire I<w> (a capo) o I<W> (non a capo) per sovrascrivere il comportamento predefinito specificato dall'opzione globale B<wrap>.

note: type: textblock
en: Example: WE<lt>chapterE<gt>E<lt>titleE<gt>
it: Esempio: WE<lt>chapterE<gt>E<lt>titleE<gt>

note: type: textblock
en: Space-separated list of tag's attributes you want to translate.  You can specify the attributes by their name (for example, "lang"), but you can prefix it with a tag hierarchy, to specify that this attribute will only be translated when it's in the specified tag. For example: E<lt>bbbE<gt>E<lt>aaaE<gt>lang specifies that the lang attribute will only be translated if it's in an E<lt>aaaE<gt> tag, and it's in a E<lt>bbbE<gt> tag.
it: Elenco separato da spazi di attributi del tag che si desidera tradurre. Si può specificare gli attributi in base al loro nome (ad esempio, "lang"), ma si può anche anteporre una gerarchia di tag, per specificare che questo attributo verrà tradotto solo quando si trova nel tag specificato. Ad esempio: E<lt>bbbE<gt>E<lt>aaaE<gt>lang specifica che l'attributo lang verrà tradotto solo se si trova in un tag E<lt>aaaE<gt> in un tag E<lt>bbbE<gt>.

note: type: textblock
en: Do not translate attributes in inline tags.  Instead, replace all attributes of a tag by po4a-id=<id>.
it: Non tradurre gli attributi nei tag in linea. Invece, sostituisci tutti gli attributi di un tag con po4a-id=<id>.

note: type: textblock
en: This is useful when attributes shall not be translated, as this simplifies the strings for translators, and avoids typos.
it: Utile quando gli attributi non devono essere tradotti, poiché semplifica le stringhe per i traduttori ed evita errori di battitura.

note: type: textblock
en: Space-separated list of tags which should not be treated as tags.  These tags are treated as inline, and do not need to be closed.
it: Elenco separato da spazi di tag che non devono essere trattati come tag. Questi tag sono trattati come in linea e non devono essere chiusi.

note: type: textblock
en: Space-separated list of tags which should break the sequence.  By default, all tags break the sequence.
it: Elenco separato da spazi di tag che dovrebbero interrompere la sequenza. Per impostazione predefinita, tutti i tag interrompono la sequenza.

note: type: textblock
en: The tags must be in the form <aaa>, but you can join some (<bbb><aaa>), if a tag (<aaa>) should only be considered when it's within another tag (<bbb>).
it: I tag devono essere nella forma <aaa>, ma si possono unire ad altri, ad esempio (<bbb><aaa>), se il tag (<aaa>) deve essere considerato solo quando si trova all'interno di un altro tag (<bbb>).

note: type: textblock
en: Please note a tag should be listed in only one of the B<break>, B<inline> B<placeholder>, or B<customtag> setting string.
it: Tenere presente che un tag deve essere elencato solo in una delle stringhe di impostazione B<break>, B<inline> B<placeholder> o B<customtag>.

note: type: textblock
en: Space-separated list of tags which should be treated as inline.  By default, all tags break the sequence.
it: Elenco separato da spazi di tag che devono essere trattati come in linea. Per impostazione predefinita, tutti i tag interrompono la sequenza.

note: type: textblock
en: Space-separated list of tags which should be treated as placeholders.  Placeholders do not break the sequence, but the content of placeholders is translated separately.
it: Elenco separato da spazi di tag che devono essere trattati come segnaposto. I segnaposto non interrompono la sequenza, ma il contenuto dei segnaposto viene tradotto separatamente.

note: type: textblock
en: The location of the placeholder in its block will be marked with a string similar to:
it: La posizione del segnaposto nel suo blocco sarà contrassegnata da una stringa simile a:

note: type: textblock
en: By default, Processing Instructions (i.e., C<E<lt>? ... ?E<gt>> tags) are handled as inline tags.  Pass this option if you want the PI to be handled as breaking tag.  Note that unprocessed PHP tags are handled as Processing Instructions by the parser.
it: Per impostazione predefinita, le istruzioni di elaborazione (ovvero i tag C<E<lt>? ... ?E<gt>>) vengono gestite come tag in linea. Passare questa opzione se si vuole che il PI venga gestito come tag di rottura. Si noti che i tag PHP non elaborati vengono gestiti come istruzioni di elaborazione dall'analizzatore.

note: type: textblock
en: Space separated list of tags that the module should not try to set by default in any category.
it: Elenco di tag separati da spazi che il modulo non dovrebbe provare a impostare per impostazione predefinita in nessuna categoria.

note: type: textblock
en: If you have a tag which has its default setting by the subclass of this module but you want to set alternative setting, you need to list that tag as a part of the B<nodefault> setting string.
it: Se si ha un tag che ha la sua impostazione predefinita dalla sottoclasse di questo modulo ma si vuole impostare un'impostazione alternativa, si deve elencare quel tag come parte della stringa di impostazione B<nodefault>.

note: type: textblock
en: Support C preprocessor directives.  When this option is set, po4a will consider preprocessor directives as paragraph separators.  This is important if the XML file must be preprocessed because otherwise the directives may be inserted in the middle of lines if po4a consider it belong to the current paragraph, and they won't be recognized by the preprocessor.  Note: the preprocessor directives must only appear between tags (they must not break a tag).
it: Supporta le direttive del preprocessore C. Quando questa opzione è impostata, po4a considererà le direttive del preprocessore come separatori di paragrafo. Ciò è importante se il file XML deve essere preprocessato perché altrimenti le direttive potrebbero essere inserite in mezzo alle righe, se po4a le considerasse appartenenti al paragrafo corrente, e quindi non verrebbero riconosciute dal preprocessore. Nota: le direttive del preprocessore devono apparire solo tra i tag (non devono interrompere un tag).

note: type: textblock
en: Space-separated list of tags you want to translate.
it: Elenco separato da spazi di marcatori che si intende tradurre.

note: type: textblock
en: You can also specify some tag options by putting some characters in front of the tag hierarchy.  This overrides the default behavior specified by the global B<wrap> and B<defaulttranslateoption> option.
it: Si può inoltre specificare alcune opzioni di tag, inserendo alcuni caratteri davanti alla gerarchia dei tag. Ciò supera il comportamento predefinito specificato dalle opzioni globali B<wrap> e B<defaulttranslateoption>.

note: type: textblock
en: Tags should be translated and content can be re-wrapped.
it: I tag devono essere tradotti e il contenuto può essere riformattatato.

note: type: textblock
en: Tags should be translated and content should not be re-wrapped.
it: I tag devono essere tradotti e il contenuto non può essere riformattatato.

note: type: textblock
en: Tags should be translated inline.
it: I tag devono essere tradotti in linea.

note: type: textblock
en: Tags should be translated as placeholders.
it: I tag devono essere tradotti come segnaposto.

note: type: textblock
en: Internally, the XML parser only cares about these four options: I<w> I<W> I<i> I<p>.
it: Internamente, l'analizzatore XML si preoccupa solo di queste quattro opzioni: I<w> I<W> I<i> I<p>.

note: type: textblock
en: * Tags listed in B<break> are set to I<w> or I<W> depending on the B<wrap> option.
it: * I tag elencati in B<break> sono impostati a I<w> o I<W> a seconda dell'opzione B<wrap>.

note: type: textblock
en: * Tags listed in B<inline> are set to I<i>.
it: * I tag elencati in B<inline> sono impostati a I<i>.

note: type: textblock
en: * Tags listed in B<placeholder> are set to I<p>.
it: * I tag elencati in B<placeholder> sono impostati a I<p>.

note: type: textblock
en: * Tags listed in B<untranslated> are without any of these options set.
it: * I tag elencati in B<untranslated> sono senza alcuna di queste opzioni impostate.

note: type: textblock
en: You can verify actual internal parameter behavior by invoking B<po4a> with B<--debug> option.
it: È possibile verificare il comportamento effettivo dei parametri interni invocando B<po4a> con l'opzione B<--debug>.

note: type: textblock
en: Please note a tag should be listed in either B<translated> or B<untranslated> setting string.
it: Si noti che un tag va elencato nella stringa di impostazione B<translated> o B<untranslated>.

note: type: textblock
en: Space-separated list of tags you do not want to translate.
it: Elenco separato da spazi di marcatori che non si intende tradurre.

note: type: textblock
en: Please note a translatable inline tag in an untranslated tag is treated as a translatable breaking tag, I<i> setting is dropped and I<w> or I<W> is set depending on the B<wrap> option.
it: Si noti che un tag in linea traducibile in un tag non tradotto viene trattato come un tag di rottura traducibile, l'impostazione I<i> viene eliminata e I<w> o I<W> viene impostato a seconda dell'opzione B<wrap>.

note: type: textblock
en: The default categories for tags that are not in any of the translated, untranslated, break, inline, or placeholder.
it: Le categorie predefinite, per i tag che non fanno parte di translated, untranslated, break, inline o placeholder.

note: type: textblock
en: This is a set of letters as defined in B<translated> and this setting is only valid for translatable tags.
it: È un insieme di lettere come definito in B<translated> e questa impostazione è valida solo per i tag traducibili.

note: type: =head1
en: WRITING DERIVATIVE MODULES
it: SCRIVERE MODULI DERIVATI

note: type: =head2
en: DEFINE WHAT TAGS AND ATTRIBUTES TO TRANSLATE
it: DEFINIRE CHE MARCATORI E ATTRIBUTI TRADURRE

note: type: textblock
en: The simplest customization is to define which tags and attributes you want the parser to translate.  This should be done in the initialize function.  First you should call the main initialize, to get the command-line options, and then, append your custom definitions to the options hash.  If you want to treat some new options from command line, you should define them before calling the main initialize:
it: La personalizzazione più semplice consiste nel definire quali tag e attributi si desidera che l'analizzatore traduca. Ciò dovrebbe essere fatto nella funzione di inizializzazione. Per prima cosa si dovrebbe chiamare l'inizializzazione principale, per ottenere le opzioni della riga di comando, quindi aggiungere le proprie definizioni personalizzate all'hash delle opzioni. Se vuole trattare alcune nuove opzioni dalla riga di comando, si deve definirle prima di chiamare l'inizializzazione principale:

note: type: textblock
en: You should use the B<_default_inline>, B<_default_break>, B<_default_placeholder>, B<_default_translated>, B<_default_untranslated>, and B<_default_attributes> options in derivative modules. This allow users to override the default behavior defined in your module with command line options.
it: Si dovrebbe usare le opzioni B<_default_inline>, B<_default_break>, B<_default_placeholder>, B<_default_translated>, B<_default_untranslated> e B<_default_attributes> nei moduli derivati. Ciò consente di superare il comportamento predefinito definito nel modulo, con le opzioni a riga di comando.

note: type: textblock
en: If you don't like the default behavior of this xml module and its derivative modules, you can provide command line options to change their behavior.
it: Se non ci piace il comportamento predefinito di questo modulo xml e dei suoi moduli derivati, si può fornire delle opzioni a riga di comando per modificarne il comportamento.

note: type: textblock
en: See L<Locale::Po4a::Docbook(3pm)|Locale::Po4a::Docbook>,
it: Consultare L<Locale::Po4a::Docbook(3pm)|Locale::Po4a::Docbook>,

note: type: textblock
en: Another simple step is to override the function "found_string", which receives the extracted strings from the parser, in order to translate them.  There you can control which strings you want to translate, and perform transformations to them before or after the translation itself.
it: Un altro semplice passo è fare l'override della funzione "found_string", che riceve le stringhe estratte dall'analizzatore, in modo da tradurle. Lì si può controllare quali stringhe si vuole tradurre ed eseguire trasformazioni su esse, prima o dopo la traduzione stessa.

note: type: textblock
en: It receives the extracted text, the reference on where it was, and a hash that contains extra information to control what strings to translate, how to translate them and to generate the comment.
it: Riceve il testo estratto, il riferimento su dove si trovava e un hash che contiene informazioni extra per controllare quali stringhe tradurre, come tradurle e generare il commento.

note: type: textblock
en: The content of these options depends on the kind of string it is (specified in an entry of this hash):
it: Il contenuto di queste opzioni dipende dal tipo di stringa (specificato in una voce di questo hash):

note: type: textblock
en: The found string is the content of a translatable tag. The entry "tag_options" contains the option characters in front of the tag hierarchy in the module "tags" option.
it: La stringa trovata è il contenuto di un tag traducibile. La voce "tag_options" contiene i caratteri dell'opzione prima della gerarchia delle variabili nell'opzione "tag" del modulo.

note: type: =item
en: type="attribute"
it: type="attributo"

note: type: textblock
en: Means that the found string is the value of a translatable attribute. The entry "attribute" has the name of the attribute.
it: Significa che la stringa trovata è il valore di un attributo traducibile. La voce "attributo" ha il nome dell'attributo.

note: type: textblock
en: It must return the text that will replace the original in the translated document. Here's a basic example of this function:
it: Deve restituire il testo che sostituirà l'originale nel documento tradotto. Ecco un esempio di base di questa funzione:

note: type: textblock
en: There's another simple example in the new Dia module, which only filters some strings.
it: C'è un altro semplice esempio nel nuovo modulo Dia, che filtra solo alcune stringhe.

note: type: =head2
en: MODIFYING TAG TYPES (TODO)
it: MODIFICA DEI TIPI DI TAG (TODO)

note: type: textblock
en: This is a more complex one, but it enables a (almost) total customization.  It's based on a list of hashes, each one defining a tag type's behavior. The list should be sorted so that the most general tags are after the most concrete ones (sorted first by the beginning and then by the end keys). To define a tag type you'll have to make a hash with the following keys:
it: Questo è più complesso, ma consente una personalizzazione (quasi) totale. Si basa su un elenco di hash, ognuno dei quali definisce il comportamento di un tipo di tag. L'elenco dovrebbe essere ordinato in modo che i tag più generali vengano dopo quelli più specifici (ordinati prima per l'inizio e poi per le chiavi di fine). Per definire un tipo di tag si dovrà creare un hash con le seguenti chiavi:

note: type: textblock
en: Specifies the beginning of the tag, after the "E<lt>".
it: Specifica l'inizio del tag, dopo del "E<lt>".

note: type: textblock
en: Specifies the end of the tag, before the "E<gt>".
it: Specifica la fine del tag, prima del "E<gt>".

note: type: textblock
en: It says if this is a breaking tag class.  A non-breaking (inline) tag is one that can be taken as part of the content of another tag.  It can take the values false (0), true (1) or undefined.  If you leave this undefined, you'll have to define the f_breaking function that will say whether a concrete tag of this class is a breaking tag or not.
it: Indica se la classe tag è una classe di tag di interruzione (breaking). Un tag di non interruzione (non-breaking) (in linea) è untag che può essere preso come parte del contenuto di un altro tag. Può assumere i valori falso (0), vero (1) o non definito. Se si lascia indefinito, si dovrà definire la funzione f_breaking che dirà se un tag effettivamente di questa classe è un tag di interruzione o meno.

note: type: textblock
en: It's a function that will tell if the next tag is a breaking one or not.  It should be defined if the B<breaking> option is not.
it: È una funzione che dirà se il tag successivo è di interruzione o meno. Dovrebbe essere definita se l'opzione B<breaking> non lo è.

note: type: textblock
en: If you leave this key undefined, the generic extraction function will have to extract the tag itself.  It's useful for tags that can have other tags or special structures in them, so that the main parser doesn't get mad.  This function receives a boolean that says if the tag should be removed from the input stream or not.
it: Se si lascia questa chiave indefinita, la funzione di estrazione generica dovrà estrarre il tag stesso. È utile per i tag che possono avere altri tag o strutture speciali al loro interno, in modo che l'analizzatore principale non vada in confusione. Questa funzione riceve un booleano che dice se il tag deve essere rimosso o meno dal flusso di ingresso.

note: type: textblock
en: This function receives the tag (in the get_string_until() format) and returns the translated tag (translated attributes or all needed transformations) as a single string.
it: Questa funzione riceve il tag (nel formato get_string_until()) e restituisce il tag tradotto (attributi tradotti o tutte le trasformazioni necessarie) in forma di stringa singola.

note: type: =head2
en: WORKING WITH TAGS
it: LAVORARE CON I TAG

note: type: textblock
en: This function returns the path to the current tag from the document's root, in the form E<lt>htmlE<gt>E<lt>bodyE<gt>E<lt>pE<gt>.
it: Questa funzione restituisce il percorso del tag corrente dalla radice del documento, nella forma E<lt>htmlE<gt>E<lt>bodyE<gt>E<lt>pE<gt>.

note: type: textblock
en: An additional array of tags (without brackets) can be passed as argument.  These path elements are added to the end of the current path.
it: Si può passare come argomento anche una schiera array di tag (senza parentesi) aggiuntivi. Questi elementi del percorso vengono aggiunti alla fine del percorso corrente.

note: type: textblock
en: This function returns the index from the tag_types list that fits to the next tag in the input stream, or -1 if it's at the end of the input file.
it: Questa funzione restituisce l'indice dall'elenco tag_types che si adatta al tag successivo nel flusso di ingresso o -1 se si trova alla fine del file di ingresso.

note: type: textblock
en: Here, the tag has structure started by E<lt> and end by E<gt> and it can contain multiple lines.
it: Qui, il tag ha una struttura che inizia con E<lt> e finisce con E<gt> e può contenere più righe.

note: type: textblock
en: This works on the array C<< @{$self->{TT}{doc_in}} >> holding input document data and reference indirectly via C<< $self->shiftline() >> and C<< $self->unshiftline($$) >>.
it: Questo funziona sull'array C<< @{$self->{TT}{doc_in}} >> che contiene i dati del documento in ingresso e fa riferimento indirettamente tramite C<< $self->shiftline() >> e C<< $self- >unshiftline($$) >>.

note: type: textblock
en: This function returns the next tag from the input stream without the beginning and end, in an array form, to maintain the references from the input file.  It has two parameters: the type of the tag (as returned by tag_type) and a boolean, that indicates if it should be removed from the input stream.
it: Questa funzione restituisce il tag successivo dal flusso di ingresso senza l'inizio e la fine, in forma di matrice, per mantenere i riferimenti dal file di ingresso. Ha due parametri: il tipo del tag (come restituito da tag_type) e un valore booleano, che indica se deve essere rimosso dal flusso di ingresso.

note: type: textblock
en: This function returns the name of the tag passed as an argument, in the array form returned by extract_tag.
it: Questa funzione restituisce il nome del tag passato come argomento, nel formato array restituito da extract_tag.

note: type: textblock
en: This function returns a boolean that says if the next tag in the input stream is a breaking tag or not (inline tag).  It leaves the input stream intact.
it: Questa funzione restituisce un valore booleano che dice se il tag successivo nel flusso di ingresso è un tag di interruzione o meno (tag in linea). Lascia intatto il flusso di ingresso.

note: type: textblock
en: This function translates the next tag from the input stream.  Using each tag type's custom translation functions.
it: Questa funzione traduce il tag successivo dal flusso di ingresso. Usata dalle funzioni di traduzione personalizzate di tutti i tipi di tag.

note: type: textblock
en: This function returns a string value that says if the first argument (a tag hierarchy) matches any of the tags from the second argument (a list of tags or tag hierarchies). If it doesn't match, it returns 0. Else, it returns the matched tag's options (the characters in front of the tag) or 1 (if that tag doesn't have options).
it: Questa funzione restituisce un valore stringa che indica se il primo argomento (una gerarchia di tag) corrisponde a uno dei tag del secondo argomento (un elenco di tag o gerarchie di tag). Se non corrisponde, restituisce 0. Altrimenti, restituisce le opzioni del tag corrispondente (i caratteri davanti al tag) o 1 (se quel tag non ha opzioni).

note: type: =head2
en: WORKING WITH ATTRIBUTES
it: LAVORARE CON GLI ATTRIBUTI

note: type: textblock
en: This function handles the translation of the tags' attributes. It receives the tag without the beginning / end marks, and then it finds the attributes, and it translates the translatable ones (specified by the module option B<attributes>).  This returns a plain string with the translated tag.
it: Questa funzione gestisce la traduzione degli attributi dei tag. Riceve il tag senza i segni di inizio/fine, quindi trova gli attributi e traduce quelli traducibili (specificati dall'opzione del modulo B<attributes>). Ciò restituisce una stringa semplice con il tag tradotto.

note: type: =head2
en: WORKING WITH TAGGED CONTENTS
it: LAVORARE CON CONTENUTI MARCATI

note: type: textblock
en: This function gets the text until the next breaking tag (not inline) from the input stream.  Translate it using each tag type's custom translation functions.
it: Questa funzione ottiene il testo fino al successivo tag di interruzione (non in linea) dal flusso di ingresso. La si traduca usando le funzioni di traduzione personalizzate di ciascun tipo di tag.

note: type: =head2
en: WORKING WITH THE MODULE OPTIONS
it: LAVORARE CON LE OPZIONI DEL MODULO

note: type: textblock
en: This function fills the internal structures that contain the tags, attributes and inline data with the options of the module (specified in the command-line or in the initialize function).
it: Questa funzione riempie le strutture interne che contengono i tag, gli attributi e i dati in linea con le opzioni del modulo (specificate nella riga di comando o nella funzione di inizializzazione).

note: type: =head2
en: GETTING TEXT FROM THE INPUT DOCUMENT
it: RICAVARE IL TESTO DAL DOCUMENTO IN INGRESSO

note: type: textblock
en: This function returns an array with the lines (and references) from the input document until it finds the first argument.  The second argument is an options hash. Value 0 means disabled (the default) and 1, enabled.
it: Questa funzione restituisce un array con le righe (e i riferimenti) dal documento di ingresso finché non trova il primo argomento. Il secondo argomento è un hash di opzioni. Il valore 0 significa disabilitata (valore predefinito) e 1, abilitata.

note: type: textblock
en: The valid options are:
it: Le opzioni valide sono:

note: type: textblock
en: This makes the returned array to contain the searched text
it: Questo fa in modo che l'array restituito contenga il testo cercato

note: type: textblock
en: This removes the returned stream from the input
it: Questo rimuove il flusso restituito dall'ingresso

note: type: textblock
en: This ensures that the searched text is outside any quotes
it: Questo si assicura che il testo cercato sia fuori da ogni virgolettatura

note: type: textblock
en: This denotes that the first argument is a regular expression rather than an plain string
it: Indica che il primo argomento è un'espressione regolare piuttosto che una semplice stringa

note: type: textblock
en: This function receives as argument the reference to a paragraph (in the format returned by get_string_until), skips his heading spaces and returns them as a simple string.
it: Questa funzione riceve come argomento il riferimento a un paragrafo (nel formato restituito da get_string_until), salta i suoi spazi di intestazione e li restituisce come stringa semplice.

note: type: textblock
en: This function returns a simple string with the text from the argument array (discarding the references).
it: Questa funzione restituisce una stringa semplice con il testo dall'array di argomenti (senza i riferimenti).

note: type: textblock
en: This module can translate tags and attributes.
it: Questo modulo può tradurre tag e attributi.

note: type: textblock
en: DOCTYPE (ENTITIES)
it: TIPO DI DOCUMENTO (ENTITÀ)

note: type: textblock
en: There is a minimal support for the translation of entities. They are translated as a whole, and tags are not taken into account. Multilines entities are not supported and entities are always rewrapped during the translation.
it: C'è un supporto minimo per la traduzione di entità. Vengono tradotte in un blocco e i tag non vengono presi in considerazione. Le entità multilinea non sono supportate; le entità vengono sempre riformattate durante la traduzione.

note: type: textblock
en: MODIFY TAG TYPES FROM INHERITED MODULES (move the tag_types structure inside the $self hash?)
it: MODIFICA I TIPI DI TAG DAI MODULI EREDITATI (sposta la struttura tag_types all'interno dell'hash $self?)

note: type: verbatim
en:  Copyright © 2004 Jordi Vilalta  <jvprat@gmail.com>
     Copyright © 2008-2009 Nicolas François <nicolas.francois@centraliens.net>
it:  Copyright © 2004 by Jordi Vilalta  <jvprat@gmail.com>
     Copyright © 2008-2009 by Nicolas François <nicolas.francois@centraliens.net>

note: type: textblock
en: Locale::Po4a::Yaml - convert YAML files from/to PO files
it: Locale::Po4a::Yaml - converte file YAML da/a file PO

note: type: textblock
en: Locale::Po4a::Yaml is a module to help the translation of Yaml files into other [human] languages.
it: Locale::Po4a::Yaml è un modulo che serve per aiutare la traduzione di file Yaml in altre lingue.

note: type: textblock
en: The module extracts the value of YAML hashes and arrays. Hash keys are not extracted.
it: Il modulo estrae il valore di hash e array YAML. Le chiavi hash non vengono estratte.

note: type: textblock
en: NOTE: This module parses the YAML file with YAML::Tiny.
it: NOTA: questo modulo analizza il file YAML con YAML::Tiny.

note: type: textblock
en: Space-separated list of hash keys to process for extraction, all other keys are skipped.  Keys are matched with a case-sensitive match.  If B<paths> and B<keys> are used together, values are included if they are matched by at least one of the options.  Arrays values are always returned unless the B<skip_array> option is provided.
it: Elenco separato da spazi di chiavi hash da elaborare per l'estrazione, tutte le altre chiavi vengono ignorate. Le chiavi vengono confrontate con distinzione tra maiuscole e minuscole. Se B<paths> e B<keys> vengono utilizzati insieme, i valori vengono inclusi se corrispondono ad almeno una delle opzioni. I valori degli array vengono sempre restituiti a meno che non venga fornita l'opzione B<skip_array>.

note: type: textblock
en: Comma-separated list of hash paths to process for extraction, all other paths are skipped. Paths are matched with a case-sensitive match.  If B<paths> and B<keys> are used together, values are included if they are matched by at least one of the options.  Arrays values are always returned unless the B<skip_array> option is provided.
it: Elenco separato da virgole di percorsi hash da elaborare per l'estrazione, tutti gli altri percorsi vengono ignorati. I percorsi vengono confrontati con distinzione tra maiuscole e minuscole. Se B<paths> e B<keys> vengono utilizzati insieme, i valori vengono inclusi se corrispondono ad almeno una delle opzioni. I valori degli array vengono sempre restituiti a meno che non venga fornita l'opzione B<skip_array>.

note: type: textblock
en: Do not translate array values.
it: Non tradurre il valori array.
