po4a 0.43 - en to pt translation catalogue (1093 entries)

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

note: type: Content of: <refentry><refmeta><refmiscinfo>
en: Po4a Tools
pt: Ferramentas Po4a

note: type: Content of: <refentry><refnamediv><refpurpose>
en: display a translated man page according to a PO
pt: exibe um manual traduzido de acordo com um PO

note: type: Content of: <refentry><refsynopsisdiv><cmdsynopsis>
en: <command>po4a-display-man</command> <arg choice='plain'><option>-p</option> </arg> <arg choice='plain'><replaceable>PO_FILE</replaceable></arg> <arg choice='opt'><arg choice='plain'><option>-m</option> </arg><arg choice='plain'><replaceable>MASTER_FILE</replaceable></arg></arg> <arg choice='opt'><arg choice='plain'><option>-o</option> </arg><arg choice='plain'><replaceable>PO4A_OPT</replaceable></arg></arg>
pt: <command>po4a-display-man</command> <arg choice='plain'><option>-p</option> </arg> <arg choice='plain'><replaceable>FICHEIRO_PO</replaceable></arg> <arg choice='opt'><arg choice='plain'><option>-m</option> </arg><arg choice='plain'><replaceable>FICHEIRO_MESTRE</replaceable></arg></arg> <arg choice='opt'><arg choice='plain'><option>-o</option> </arg><arg choice='plain'><replaceable>PO4A_OPT</replaceable></arg></arg>

note: type: =head1
en: DESCRIPTION
pt: DESCRIÇÃO

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.
pt: Os tradutores podem usar <command>po4a-display-man</command> para ver como a sua tradução de uma página man será renderizada para os utilizadores finais, sem recompilar e reinstalar todo o projeto.

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.
pt: Este script só funciona com páginas de manual escritas diretamente em <emphasis remap='I'>nroff</emphasis> e manipuladas pelo módulo <emphasis remap='I'>man</emphasis> do po4a. Manuais gerados de outros formatos, como DocBook ou POD, não são suportados. Veja<citerefentry><refentrytitle>po4a-display-pod</refentrytitle><manvolnum>1</manvolnum></citerefentry> para um suporte equivalente de documentos <emphasis remap='I'>POD</emphasis>.

note: type: =head1
en: OPTIONS
pt: OPÇÕES

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><term>
en: <option>-p </option><replaceable>PO_FILE</replaceable>
pt: <option>-p </option><replaceable>FICHEIRO_PO</replaceable>

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>
en: The PO file containing the translations.
pt: O ficheiro PO que contém as traduções.

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><term>
en: <option>-m </option><replaceable>MASTER_FILE</replaceable>
pt: <option>-m </option><replaceable>FICHEIRO_MESTRE</replaceable>

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.
pt: A página do manual original.  Pode ser o caminho absoluto ou relativo à página do manual original (compactada ou não), o nome da página do manual e secção da página do manual (a usar o formato man.section). Quando o documento mestre não é fornecido com a opção <option>-m</option>, o <command>po4a-display-man</command> tenta encontrar a página do manual original, baseada na linha de referência da primeira cadeia no 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>.
pt: Algumas opções para passar para <citerefentry><refentrytitle>po4a-translate</refentrytitle><manvolnum>1</manvolnum></citerefentry>.

note: type: =head1
en: SEE ALSO
pt: VEJA TAMBÉM

note: type: Content of: <refentry><refsect1><title>
en: AUTHOR
pt: AUTOR

note: type: Content of: <refentry><refnamediv><refpurpose>
en: display of a translated POD file according to a PO
pt: exibição de um ficheiro POD traduzido de acordo com um 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>
pt: <command>po4a-display-pod</command> <arg choice='plain'><option>-p </option></arg> <arg choice='plain'><replaceable>FICHEIRIO_PO</replaceable></arg> <arg choice='plain'><option>-m </option></arg> <arg choice='plain'><replaceable>FICHEIRO_POD</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.
pt: Os tradutores podem usar <command>po4a-display-pod</command> para ver como a sua tradução de uma página de man será renderizada aos utilizadores finais, sem recompilar e reinstalar o projeto inteiro.  Na maioria das vezes, o ficheiro POD está disponível apenas no pacote fonte ou embutido no script Perl.

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><term>
en: <option>-m </option><replaceable>POD_FILE</replaceable>
pt: <option>-m </option><replaceable>FICHEIRO_POD</replaceable>

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>
en: The original POD file used by po4a to generate PO file.
pt: O ficheiro POD original usado pelo po4a para gerar o ficheiro PO.

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

note: type: textblock
en: po4a - update both the PO files and translated documents in one shot
pt: po4a - atualizar ambos os ficheiros PO e documentos traduzidos numa só vez

note: type: =head1
en: SYNOPSIS
pt: RESUMO

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.
pt: po4a (PO for anything) facilita a manutenção de tradução da documentação a usar as ferramentas clássicas do gettext. A característica principal do po4a é que ele dissocia a tradução do conteúdo da estrutura documental. Consulte a página L<po4a(7)> para uma introdução suave a este projeto.

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.
pt: Ao executar, B<po4a> analisa todos os ficheiros de documentação especificados no seu ficheiro de configuração. Atualiza os ficheiros PO (contendo a tradução) para refletir qualquer alteração na documentação e produzir uma documentação traduzida, injetando a tradução do conteúdo (encontrado nos ficheiros PO) na estrutura do documento mestre original.

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.
pt: Inicialmente, os ficheiros PO apenas contêm as cadeias para traduzir da documentação original. Este formato de ficheiro permite que os tradutores forneçam manualmente uma tradução para cada parágrafo extraído por B<po4a>. Se a documentação for modificada após a tradução, B<po4a> marca as traduções correspondentes como "fuzzy" no ficheiro PO para solicitar uma revisão manual pelos tradutores. Os tradutores também podem fornecer o chamado "addendum" (adendo), que são conteúdo extra afirmando por exemplo quem fez a tradução e como relatar bugs.

note: type: verbatim
en:  master documents ---+---->-------->---------+
      (doc authoring)    |                       |
                         V   (po4a executions)   >-----+--> translated
                         |                       |     |     documents
     existing PO files -->--> updated PO files >-+     |
          ^                            |               |
          |                            V               |
          +----------<---------<-------+               ^
           (manual translation process)                |
                                                       |
     addendum -->--------------------------------------+
pt:  documentos mestres -+----->-------->---------+
      (criação de docs)  |                        |
                         V  (execuções do po4a)   >----+--> documentos
                         |                        |    |    traduzidos
      ficheiros PO existentes ------->-----> ficheiros PO atualizados-->--+    |
         ^                             |               |
         |                             V               ^
         +----------<---------<--------+               |
          (processo de tradução manual)                |
                                                       |
     adendo ---->--------------------------------------+

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.
pt: O fluxo de trabalho de B<po4a> é assíncrono, conforme adequado para projetos de código aberto. Os autores de documentação escrevem os documentos mestre no seu próprio ritmo. Os tradutores revisam e atualizam as traduções nos ficheiros PO. Os mantenedores executam novamente B<po4a> quando necessário, para refletir qualquer alteração na documentação original para os ficheiros PO e para produzir traduções de documentação atualizadas, injetando a mais recente tradução para a mais recente estrutura de documentos.

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.
pt: Por predefinição, um documento traduzido é produzido quando pelo menos 80% do seu conteúdo é traduzido. O texto não traduzido é mantido no idioma original. A documentação produzida mistura idiomas se a tradução não estiver completa. Pode alterar o limite de 80% com a opção I<-keep> descrita abaixo. Note no entanto que descartar traduções assim que não são 100% pode ser desanimador para os tradutores cujo trabalho quase nunca será mostrado aos utilizadores, enquanto mostrar "traduções" que são muito incompletas pode ser um problema para os utilizadores finais.

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.
pt: Armazenar os ficheiros de documentação traduzidos no sistema de controle de versão é provavelmente uma má ideia, uma vez que eles são gerados automaticamente. Os ficheiros preciosos são os ficheiros PO, que contêm o trabalho duro dos seus colegas tradutores. Além disso, algumas pessoas acham mais fácil interagir com os tradutores através de uma plataforma online como o S<weblate>, mas naturalmente que isto é totalmente opcional.

note: type: =head2
en: Quick start tutorial
pt: Tutorial de início rápido

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.
pt: Vamos supor que mantém um programa chamado B<foo> que tem uma página man F<man/foo.1> escrito em inglês (o idioma-ponte na maioria dos projetos de código aberto, mas B<po4a> pode ser usado de ou para qualquer idioma). Um tempo atrás, alguém forneceu uma tradução em alemão chamada F<man/foo.de.1> e desapareceu. Este é um problema porque acabou de ter um relatório de bug dizendo que a sua documentação contém uma informação gravemente enganosa que deve ser corrigida em todos os idiomas, mas não fala alemão para que só possa modificar o original, não a tradução. Agora, outro colaborador quer contribuir com uma tradução para japonês, um idioma que também não domina.

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.
pt: É hora de converter a sua documentação para B<po4a> para resolver os seus pesadelos de manutenção de documentação. Quer atualizar o documento quando necessário, quer facilitar o trabalho dos seus colegas tradutores e quer garantir que os seus utilizadores nunca vejam nenhuma documentação desatualizada e, portanto, enganosa.

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.
pt: A conversão inclui dois passos: configurar a infraestrutura do po4a e converter a tradução anterior alemã para gravar o trabalho anterior. Esta última parte é feita usando S<po4a-gettextize>, como se segue. Como detalhado na documentação de L<po4a-gettextize(1)>, este processo raramente é totalmente automático, mas uma vez feito, o ficheiro B<de.po> contendo a tradução alemã pode ser integrado no seu fluxo de trabalho do po4a.

note: type: textblock
en: Let's now configure po4a. With the appropriate file layout, your configuration file could be as simple as this:
pt: Vamos agora configurar o po4a. Com a disposição de ficheiro apropriada, o seu ficheiro de configuração pode ser tão simples como este:

note: type: textblock
en: It specifies that all PO files (containing the work of the translators) are in 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>.
pt: Isso especifica que todos os ficheiros PO (contendo o trabalho dos tradutores) estão no diretório F<man/po4a/> e que tem apenas um ficheiro mestre, F<man/foo.1>. Se tivesse vários ficheiros mestres, teria várias linhas semelhantes à segunda. Cada linha também especifica onde escrever os ficheiros de tradução correspondentes. Aqui, a tradução alemã de F<man/foo.1> está em 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.
pt: A última coisa que precisamos para completar a configuração do B<po4a> é um ficheiro POT contendo o material do modelo que deve ser usado para iniciar uma nova tradução. Basta criar um ficheiro vazio com a extensão S<.pot> no S<po_directory> especificado (por exemplo, F<man/po4a/foo.pot>) e o B<po4a> irá preencher com o conteúdo esperado.

note: type: textblock
en: Here is a recap of the files in this setup:
pt: Aqui está uma recapitulação dos ficheiros nesta configuração:

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
pt:   ├── man/
      │   ├── foo.1        <- A página man original, em inglês
      │   ├── po4a/
      │   │   ├── de.po    <- O PO com tradução alemã, da gettextização
      │   │   └── foo.pot  <- O POT, modelo de futuras traduções (vazio no início)
      │   └── translated/  <- Diretório onde as traduções serão criadas
      └── po4a.cfg         <- O ficheiro de configuração

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:
pt: Uma vez configurado, a execução do B<po4a> analisará a sua documentação, atualizará o ficheiro de modelo POT, vai usá-lo para atualizar os ficheiros de tradução PO e vai usá-los para atualizar os ficheiros de tradução da documentação. Tudo num comando:

note: type: textblock
en: This is 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 a Japanese translator wants to contribute a new translation, she should rename the S<foo.pot> into S<ja.po> and complete the translation. Once you have this file, just drop it in F<man/po4a/po/>. A translated page will appear as F<man/translated/foo.ja.1> (provided that enough content is translated) when you run B<po4a> again.
pt: É isto. B<po4a> está agora totalmente configurado. Uma vez que tenha corrigido o seu erro no F<man/foo.1>, o parágrafo problemático na tradução alemã será substituído pelo texto corrigido em inglês. Misturar idiomas não é o melhor, mas é a única maneira de remover erros nas traduções que nem se percebem e garantir que o conteúdo apresentado aos utilizadores nunca seja enganoso. A atualização da tradução alemã também é muito mais fácil no ficheiro PO correspondente, então a mistura de idiomas pode não durar muito. Finalmente, quando um tradutor japonês quer contribuir com uma nova tradução, ele deve renomear o S<foo.pot> em S<ja.po> e completar a tradução. Uma vez que tem este ficheiro, basta deixá-lo em F<man/po4a/po/>. Uma página traduzida aparecerá como F<man/translated/foo.ja.1> (desde que o conteúdo suficiente seja traduzido) quando executar B<po4a> novamente.

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.
pt: Limite mínimo de percentagem de tradução para manter (ou seja, escrever) o ficheiro resultante (predefinição: 80). Ou seja, por predefinição, ficheiros têm que ser traduzidos pelo menos a 80% para serem escritos no disco.

note: type: textblock
en: Column at which we should wrap the resulting file if the format supports it (default: 76).  If the provided value is 0 or negative, then the resulting file will not be wraped at all.  This is useful with some formats that could break when rewraped.
pt: Coluna na qual devemos quebrar linha no ficheiro resultante se o formato suportar (padrão: 76). Se o valor fornecido for 0 ou negativo, o ficheiro resultante não terá quebra de linha. Isto é útil com alguns formatos que podem ficar danificados ao quebrar linha novamente.

note: type: textblock
en: Show a short help message.
pt: Mostrar uma pequena mensagem de ajuda.

note: type: textblock
en: Charset of the files containing the documents to translate. Note that all master documents must use the same charset.
pt: Conjunto de caracteres dos ficheiros que contém os documentos a traduzir. Note que todos os ficheiros mestres devem ter o mesmo conjunto de caracteres.

note: type: textblock
en: Charset of the files containing the localized documents. Note that all translated documents will use the same charset.
pt: Conjunto de caracteres dos ficheiros que contêm os documentos localizados. Note que todos os documentos traduzidos utilizarão o mesmo conjunto de caracteres.

note: type: textblock
en: Charset of the addenda. Note that all the addenda should be in the same charset.
pt: Conjunto de caracteres da adenda. Note-se que todas as adendas devem estar no mesmo conjunto de caracteres.

note: type: textblock
en: Display the version of the script and exit.
pt: Mostrar a versão do script e sai.

note: type: textblock
en: Increase the verbosity of the program.
pt: Aumenta os detalhes do programa.

note: type: textblock
en: Decrease the verbosity of the program.
pt: Diminui os detalhes do programa.

note: type: textblock
en: Output some debugging information.
pt: Produz alguma informação de depuração.

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'.
pt: Opção/ções adicional/ais para passar ao plugin de formato. Veja a documentação de cada plugin para mais informações sobre as opções válidas e os significados deles. Por exemplo, poderia passar '-o tablecells' para o analisador AsciiDoc, enquanto o analisador de texto aceitaria '-o tabs=split'.

note: type: textblock
en: Always generate the POT and PO files, even if B<po4a> considers it is not necessary.
pt: Gera sempre os ficheiros POT e PO, mesmo se B<po4a> considerar que não é necessário.

note: type: textblock
en: The default behavior (when B<--force> is not specified) is the following:
pt: O comportamento predefinido (quando B<--force> não é especificado) é o seguinte:

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.
pt: Se o ficheiro POT já existe, ele é regenerado se um documento mestre ou o ficheiro de configuração é mais recente (a menos que B<--no-update> seja fornecido). O ficheiro POT também é escrito num documento temporário e B<po4a> verifica que as mudanças são realmente necessárias.

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>).
pt: Além disso, uma tradução é regenerada somente se o documento mestre dela, o ficheiro PO, uma das suas adendas ou o ficheiro de configuração é mais recente. Para evitar tentar regenerar traduções que não passam no teste de limite (ver B<--keep>), um ficheiro com a extensão F<.po4a-stamp> pode ser criado (ver 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.
pt: Se um documento mestre incluir ficheiros, deve usar a flag B<--force> porque o tempo de modificação dos ficheiros incluídos não é tomado em conta.

note: type: textblock
en: The PO files are always re-generated based on the POT with B<msgmerge -U>.
pt: Os ficheiros PO são sempre regenerados com base em POT com 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.
pt: Diz ao B<po4a> para criar ficheiros de informação quando uma tradução não é gerada porque não atingiu o limiar. Esses ficheiros de informação são nomeados de acordo com o documento traduzido esperado, com a extensão 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.
pt: Nota: Isso só ativa a criação dos ficheiros F<.po4a-stamp>. Os ficheiros de informação são sempre utilizados se existirem e são removidos com B<--rm-translations> ou quando o ficheiro é finalmente traduzido.

note: type: textblock
en: Do not generate the translated documents, only update the POT and PO files.
pt: Não gera os documentos traduzidos, apenas atualiza os ficheiros POT e PO.

note: type: textblock
en: Do not change the POT and PO files, only the translation may be updated.
pt: Não altera os ficheiros POT e PO, apenas a tradução pode ser atualizada.

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.
pt: Mantém os ficheiros de tradução existentes mesmo se a tradução não atingir o limite especificado por B<--keep>.  Essa opção não cria ficheiros de tradução com pouco conteúdo, mas vai gravar traduções existentes que cujo nível decai devido a alterações nos ficheiros de mestre.

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.
pt: ATENÇÃO: esta opção muda o comportamento do po4a de uma maneira bastante drástica: os seus ficheiros traduzidos não serão atualizados até que a tradução melhore. Use esta opção somente se preferir enviar uma documentação traduzida desatualizada em vez de enviar apenas uma documentação não traduzida precisa.

note: type: textblock
en: Remove the translated files (implies B<--no-translations>).
pt: Remove os ficheiros traduzidos (implica B<--no-translations>).

note: type: textblock
en: This flag does nothing since 0.41, and may be removed in later releases.
pt: Esta bandeira não faz nada desde 0.41 e pode ser removida em versões posteriores.

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.
pt: Traduzir apenas o ficheiro especificado. Pode ser útil para acelerar o processamento se um ficheiro de configuração contém muitos ficheiros. Note que o que esta opção não atualiza ficheiros PO e POT.   Esta opção pode ser usada várias vezes.

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.
pt: Define uma variável que será expandida no ficheiro de configuração B<po4a>. Cada ocorrência de I<$(var)> será substituída por I<value>. Esta opção pode ser usada várias vezes.

note: type: textblock
en: Update PO files and generate translated documents only for the specified language. This option can be used multiple times.
pt: Atualiza ficheiros PO e gera documentos traduzidos apenas para o idioma especificado. Esta opção pode ser usada várias vezes.

note: type: textblock
en: Set the base directory for all input documents specified in the B<po4a> configuration file.
pt: Define o diretório de base para todos os documentos de entrada especificados no ficheiro de configuração do 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.
pt: Se ambos I<destdir> e I<srcdir> forem especificados, os ficheiros de entrada serão pesquisados nos diretórios seguintes, em ordem: I<destdir>, o diretório atual e I<srcdir>. Os ficheiros resultantes são gravados em I<destdir> se especificado, ou no diretório atual.

note: type: textblock
en: Set the base directory for all the output documents specified in the B<po4a> configuration file (see B<--srcdir> above).
pt: Define o diretório base para todos os documentos de saída especificados no ficheiro de configuração B<po4a> (veja B<--srcdir> em cima).

note: type: =head2
en: Options modifying the POT header
pt: Opções que modificam o cabeçalho do POT

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).
pt: Especifica o formato de referência. O argumento I<tipo> pode ser um de: B<never> para não produzir qualquer referência, B<file> para especificar o ficheiro sem o número da linha, B<counter> para substituir os números de linha a aumentar o contador e B<full> para incluir referências completas. (predefinição: full).

note: type: =item
en: B<--wrap-po> B<no>|B<newlines>|I<number> (default: 76)
pt: B<--wrap-po> B<no>|B<newlines>|I<number> (predefinição: 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.
pt: Especifica como o ficheiro po deve ter a quebra de linha. Isso permite escolher entre ficheiros que tem boa quebra de linha, mas que podem levar a conflitos de git ou ficheiros que são mais fáceis de manipular automaticamente, mas mais difíceis de ler para humanos.

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.
pt: Historicamente, o pacote gettext reformatou os ficheiros po na 77ª coluna para questões cosméticas. Esta opção especifica o comportamento de po4a. Se for definido como um valor numérico, o po4a quebrará linha do ficheiro po após esta coluna e após novas linhas no conteúdo. Se for definido como B<newlines>, o po4a dividirá apenas o msgid e o msgstr após as novas linhas no conteúdo. Se for definido como B<no>, o po4a não quebrará linha do ficheiro po. Os comentários de referência têm sempre as linhas quebradas pelas ferramentas do gettext que usamos 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.
pt: Observe que esta opção não afeta a maneira como o msgid e o msgstr sofrem quebra de linhas ou seja, como os caracteres de nova linha são adicionados ao conteúdo dessas cadeias.

note: type: textblock
en: Language of the source files containing the documents to translate. Note that all master documents must use the same language.
pt: Idioma dos ficheiros fonte que contêm os documentos a traduzir. Note que todos os documentos mestre devem usar o mesmo idioma.

note: type: =item
en: B<--msgid-bugs-address> I<email@address>
pt: B<--msgid-bugs-address> I<e-mail@endereço>

note: type: textblock
en: Set the report address for msgid bugs. By default, the created POT files have no Report-Msgid-Bugs-To fields.
pt: Define o endereço do relatório para bugs de msgid. Por predefinição, os ficheiros POT criados não têm campos Report-Msgid-bugs-To.

note: type: textblock
en: Set the copyright holder in the POT header. The default value is "Free Software Foundation, Inc."
pt: Define o titular dos direitos de autor no cabeçalho POT. O valor predefinido é " Free Software Foundation, Inc."

note: type: textblock
en: Set the package name for the POT header. The default is "PACKAGE".
pt: Define o nome do pacote para o cabeçalho POT. A predefinição é "PACKAGE".

note: type: textblock
en: Set the package version for the POT header. The default is "VERSION".
pt: Define a versão do pacote para o cabeçalho POT. A predefinição é "VERSION".

note: type: =head2
en: Options to modify the PO files
pt: Opções para modificar os ficheiros PO

note: type: textblock
en: Extra options for B<msgmerge>(1).
pt: Opções extra para B<msgmerge>(1).

note: type: textblock
en: Note: B<$lang> will be extended to the current language.
pt: Nota: B<$lang> será estendida ao idioma atual.

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.
pt: Esta opção remove B<--previous> a partir das opções passadas para B<msgmerge> .   Isto é necessário para suportar versões do B<gettext> antes de 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.
pt: Esta opção acrescenta B<--previous> ás opções passadas para B<msgmerge>. Isso requer B<gettext> 0.16 ou posterior e é ativado por predefinição.

note: type: =head1
en: CONFIGURATION FILE
pt: FICHEIRO DE CONFIGURAÇÃO

note: type: textblock
en: po4a expects a configuration file as argument. This file must contain the following elements:
pt: O po4a espera um ficheiro de configuração como argumento. Este ficheiro deve conter os elementos seguintes:

note: type: =item
en: The path to the PO files and the list of languages existing in the project;
pt: O caminho aos ficheiros PO e a lista de idiomas existentes no projeto;

note: type: =item
en: Optionally, some global options and so-called configuration aliases that are used as templates to configure individual master files;
pt: Opcionalmente, algumas opções globais e os chamados aliases de configuração que são usados como modelos para configurar ficheiros mestre individuais ;

note: type: =item
en: The list of each master file to translate, along with specific parameters.
pt: A lista de cada ficheiro mestre a traduzir, juntamente com parâmetros específicos.

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.
pt: Todas as linhas contêm um comando entre colchetes, seguido pelos seus parâmetros.  Os comentários começam com o caractere "#" e correm até ao fim da linha. Pode escapar do fim da linha para espalhar um comando por várias linhas.

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.
pt: Alguns exemplos completos são apresentados nesta página, enquanto outros exemplos encontram-se no diretório C<t/cfg> da distribuição fonte.

note: type: =head2
en: Finding the PO and POT files
pt: Encontrar os ficheiros PO e POT

note: type: textblock
en: The simplest solution is to explicitly give the path to POT and PO files, as follows:
pt: A solução mais simples é fornecer o caminho aos ficheiros POT e PO, da maneira seguinte:

note: type: textblock
en: This specifies the path to the POT file first, and then the paths to the German and French PO files.
pt: Isto especifica o caminho ao ficheiro POT primeiro e, em seguida, os caminhos aos ficheiros PO Alemão e Francês.

note: type: textblock
en: The same information can be written as follows to reduce the risk of copy/paste errors:
pt: A mesma informação pode ser escrita da seguinte forma para reduzir o risco de erros de cópia/colagem:

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.
pt: O componente C<$lang> é expandido automaticamente a usar a lista de idiomas fornecidos, a reduzir o risco de erro de copiar/colar quando um novo idioma é adicionado.

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.
pt: Pode compactar ainda mais as mesmas informações a fornecer apenas o caminho ao diretório que contém o seu projeto de tradução, como a seguir.

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).
pt: O diretório fornecido deve conter um conjunto de ficheiros PO, cada um chamado F<XX.po>, o C<XX> a ser o ISO 631-1 do idioma utilizado neste ficheiro. O diretório também deve conter um único ficheiro POT, com a extensão C<.pot>. Para a primeira execução, este ficheiro pode estar vazio, mas deve existir (o po4a não pode adivinhar o nome a usar antes da extensão).

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.
pt: Note que deve escolher apenas um de C<po_directory> e C<po4a_paths>. O primeiro (C<po_directory>) é mais compacto, reduz ainda mais o risco de erro de copiar/colar, mas obriga-o a usar a estrutura de projeto e os nomes de ficheiro esperados. O segundo (C<po4a_paths>) é mais explícito, provavelmente mais legível e é aconselhado quando configura o seu primeiro projeto com o po4a.

note: type: =head3
en: Centralized or split PO files?
pt: Ficheiros PO centralizados ou divididos?

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.
pt: Por predefinição, o po4a produz um único ficheiro PO por idioma de destino, a conter todo o conteúdo do seu projeto de tradução. Conforme o seu projeto cresce, o tamanho desses ficheiros pode tornar-se problemático. Ao utilizar weblate, é possível especificar prioridades para cada segmento de tradução (isto é, msgid), de modo que os importantes sejam traduzidos primeiro. Mesmo assim, algumas equipas de tradução preferem dividir o conteúdo em vários ficheiros.

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.
pt: Para ter um ficheiro PO por ficheiro mestre, basta usar a cadeia C<$master> no nome dos ficheiros PO na linha C<[po4a_paths]>, da maneira seguinte.

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.
pt: Com esta linha, o po4a produzirá ficheiros POT e PO separados para cada documento a ser traduzido. Por exemplo, se tiver 3 documentos e 5 idiomas, isto resultará em 3 ficheiros POT e 15 ficheiros PO. Estes ficheiros são nomeados conforme especificado no modelo C<po4a_paths>, com C<$master> substituído no nome de base de cada documento a ser traduzido. Em caso de conflito de nome, pode especificar o ficheiro POT a ser usado da seguinte maneira, com o parâmetro 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>).
pt: Este recurso também pode ser usado para agrupar vários ficheiros traduzidos no mesmo ficheiro POT. O exemplo a seguir só produz 2 ficheiros POT: F<l10n/po/foo.pot> (contendo o material de F<foo/gui.xml>) e F<l10n/po/bar.pot> (contendo o material de ambos 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.
pt: No modo split, o B<po4a> constrói um compêndio temporário durante a atualização do PO, para compartilhar as traduções entre todos os ficheiros do PO. Se dois ficheiros PO tiverem traduções diferentes para a mesma cadeia, B<po4a> marcará esta cadeia como difusa e enviará ambas as traduções em todos os ficheiros PO a conter esta cadeia. Quando atualizada pelo tradutor, a tradução é automaticamente utilizada em todos os ficheiros PO.

note: type: =head2
en: Specifying the documents to translate
pt: Especificando os documentos para traduzir

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. File names should be quoted or escaped if they contain spaces. Here is an example:
pt: Também deve listar os documentos que devem ser traduzidos. Para cada ficheiro mestre, deve especificar o analisador de formato a ser usado, o local do documento traduzido a ser produzido e, opcionalmente, alguma configuração. Nomes de ficheiros devem estar entre aspas ou escapados se eles contiverem espaços. Aqui está um exemplo:

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:
pt: Mas novamente, essas linhas complexas são difíceis de ler e modificar, por exemplo, ao adicionar um novo idioma. É muito mais simples reorganizar as coisas a usar o modelo C<$lang> da seguinte maneira:

note: type: =head2
en: Specifying options
pt: Especificando opções

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.
pt: Há dois tipos de opções: I<opções do po4a> são valores predefinidos para as opções de linha de comando po4a enquanto I<opções de formato> são usadas para alterar o comportamento dos analisadores de formato. Como uma I<opções do po4a>, pode por exemplo, especificar no seu ficheiro de configuração que o valor predefinido do parâmetro de linha de comando B<--keep> é de 50% em vez de 80%. I<Opções de formato> estão documentadas na página específica de cada módulo de análise, por exemplo, L<Locale::Po4a::Xml(3pm)>. Pode por exemplo, passar B<nostrip> para o analisador XML para não remover os espaços ao redor das cadeias extraídas.

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).
pt: Pode passar essas opções a um ficheiro mestre específico ou mesmo a uma tradução específica desse ficheiro, a usar C<opt:> e C<opt_XX:> para o idioma C<XX>. No exemplo a seguir, a opção B<nostrip> é passada ao analisador XML (para todos os idiomas), enquanto o limite será reduzido a 0% para a tradução em francês (que, portanto, é sempre mantida).

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:
pt: De qualquer forma, esses blocos de configuração devem estar localizados no final da linha. A declaração dos ficheiros deve vir primeiro, depois o adendo, se houver (veja abaixo) e somente as opções. O agrupamento de pedaços de configuração não é muito importante, pois os elementos são internamente concatenados como cadeias. Os exemplos a seguir são todos equivalentes:

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.
pt: Observe que as opções específicas do idioma não são usadas ao criar o ficheiro POT. Por exemplo, é impossível passar B<nostrip> para o analisador apenas ao criar a tradução em francês, porque o mesmo ficheiro POT é usado para atualizar todos os idiomas. Portanto, as únicas opções que podem ser específicas do idioma são as usadas na produção da tradução, como a opção C<--keep>.

note: type: =head3
en: Configuration aliases
pt: Nomes alternativos de configuração

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.
pt: Para passar as mesmas opções para vários ficheiros, o melhor é definir um alias de tipo da maneira seguinte. No próximo exemplo, C<--keep 0> é passado para todas as traduções em italiano a usar este tipo C<test>, que é uma extensão do 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.
pt: Também pode estender um tipo existente de reutilizar o mesmo nome ao alias da forma seguinte. Este não é interpretado como uma definição recursiva errada.

note: type: =head3
en: Global default options
pt: Opções predefinidas globais

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.
pt: Também pode usar as linhas C<[options]> para definir opções que devem ser usadas para todos os ficheiros, independentemente do tipo dele.

note: type: textblock
en: As with the command line options, you can abbreviate the parameters passed in the configuration file:
pt: Como nas opções da linha de comando, pode abreviar os parâmetros passados no ficheiro de configuração:

note: type: =head3
en: Option priorities
pt: Prioridades das opções

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:
pt: As opções de todas as fontes são concatenadas, a garantir que os valores predefinidos possam ser facilmente substituídos por opções mais específicas. A ordem é a seguinte:

note: type: =item
en: C<[options]> lines provide default values that can be overridden by any other source.
pt: As linhas C<[options]> fornecem valores predefinidos que podem ser substituídos por qualquer outra fonte.

note: type: =item
en: Type aliases are then used. Language specific settings override the ones applicable to all languages.
pt: Os aliases de tipo são então usados. As configurações específicas do idioma substituem as aplicáveis a todos os idiomas.

note: type: =item
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.
pt: As configurações específicas de um determinado ficheiro mestre substituem as predefinidas e as provenientes do alias de tipo. Neste caso, as configurações específicas do idioma também substituem as globais.

note: type: =item
en: Finally, parameters provided on the B<po4a> command line override any settings from the configuration file.
pt: Finalmente, os parâmetros fornecidos na linha de comando B<po4a> substituem todas as configurações do ficheiro de configuração.

note: type: =head3
en: Example
pt: Exemplo

note: type: textblock
en: Here is an example showing how to quote the spaces and quotes:
pt: Aqui está um exemplo a mostrar como citar os espaços e aspas:

note: type: =head2
en: Addendum: Adding extra content in the translation
pt: Adendo: Adicionar conteúdo extra na tradução

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.
pt: Se deseja adicionar uma secção adicional à tradução, por exemplo, para dar mérito ao tradutor, é necessário definir um adendo à linha que define o seu ficheiro mestre. Consulte a página L<po4a(7)> para obter mais detalhes sobre a sintaxe dos ficheiros de adendo.

note: type: textblock
en: You can also use language templates as follow:
pt: Também pode usar modelos de idioma da maneira seguinte:

note: type: textblock
en: If an addendum fails to apply, the translation is discarded.
pt: Se um adendo falhar ao aplicar, a tradução será descartada.

note: type: =head3
en: Modifiers for the addendum declaration
pt: Modificadores para a declaração de adendo

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.
pt: Os modificadores de adendo podem simplificar o ficheiro de configuração no caso em que nem todos os idiomas fornecem um adendo ou quando a lista de adendos muda de um idioma ao outro. O modificador é um único caractere localizado antes do nome do ficheiro.

note: type: textblock
en: Include I<addendum_path> if this file does exist, otherwise do nothing.
pt: Inclui I<addendum_path> se este ficheiro existir, caso contrário não faz nada.

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.
pt: I<addendum_path> não é uma adenda regular, mas um ficheiro a conter uma lista de adendas, uma por linha.   Cada adenda pode ser precedida por modificadores.

note: type: textblock
en: I<addendum_path> is discarded, it is not loaded and will not be loaded by any further addendum specification.
pt: I<addendum_path> é descartado, não é carregado e não será carregado por qualquer especificação de adenda.

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.
pt: O seguinte inclui um adendo em qualquer idioma, mas só se existir. Nenhum erro será relatado se o adendo não existir.

note: type: textblock
en: The following includes a list of addendum for every language:
pt: O seguinte inclui uma lista de adendos para cada idioma:

note: type: =head2
en: Filtering the translated strings
pt: Filtrar as cadeias traduzidas

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:
pt: Às vezes, deseja ocultar algumas cadeias do processo de tradução. Nesse sentido, pode atribuir um parâmetro C<pot_in> ao seu ficheiro mestre para especificar o nome do ficheiro a ser usado em vez do mestre real ao criar o ficheiro POT. Aqui está um exemplo:

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.
pt: Com essa configuração, as cadeias a serem traduzidas serão extraídas do F<book-filtered.xml> (que deve ser produzido antes da chamada de B<po4a>) enquanto os ficheiros traduzidos serão compilados do F<book.xml>. Como resultado, qualquer cadeia que faça parte de F<book.xml>, mas não em F<book-filtered.xml> não será incluída nos ficheiros PO, a impedir que os tradutores forneçam uma tradução para eles. Portanto, essas cadeias não serão modificadas ao produzir os documentos traduzidos. Isso naturalmente diminui o nível de tradução, portanto, pode precisar da opção C<--keep> para garantir que o documento seja produzido de qualquer maneira.

note: type: =head1
en: AUTHORS
pt: AUTORES

note: type: =head1
en: COPYRIGHT AND LICENSE
pt: DIREITOS DE AUTOR E LICENÇA

note: type: textblock
en: Copyright 2002-2023 by SPI, inc.
pt: Copyright 2002-2023 por SPI, inc.

note: type: textblock
en: This program is free software; you may redistribute it and/or modify it under the terms of GPL v2.0 or later (see the COPYING file).
pt: Este programa é um software livre; pode redistribuí-lo e/ou modificá-lo sob os termos da GPL v2.0 ou posterior (veja o ficheiro COPYING).

note: type: textblock
en: po4a-gettextize - convert an original file (and its translation) to a PO file
pt: po4a-gettextize - converte um ficheiro original (e a tradução dele) para um ficheiro 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>
pt: B<po4a-gettextize> B<-f> I<fmt> B<-m> I<mestre.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)
pt: (I<XX.po> é a saída, todos os outros são entradas)

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.
pt: O script B<po4a-gettextize> ajuda a converter as suas traduções anteriormente existentes num fluxo de trabalho baseado em po4a. Isto só deve ser feito uma vez para gravar uma tradução existente ao converter para po4a, não numa base regular após a conversão do seu projeto. Este processo tedioso é explicado em pormenores na Secção 'Convertendo uma tradução manual em po4a' abaixo.

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.
pt: Deve fornecer um ficheiro mestre (por exemplo, a fonte em inglês) e um ficheiro traduzido existente (por exemplo, uma tentativa de tradução anterior sem po4a). Se fornecer mais que um mestre ou ficheiros de tradução, eles serão usados em sequência, mas pode ser mais fácil gettextizar cada página ou capítulo separadamente e, em seguida, usar B<msgmerge> para fundir todos os ficheiros PO produzidos. Como preferir.

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.
pt: Se o documento mestre possui caracteres não-ASCII, o novo ficheiro PO gerado vai estar in UTF-8. Se o documento mestre estiver completamente em ASCII, o PO gerado vai usar a codificação do documento de entrada traduzido.

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.
pt: O formato da documentação que pretende processar. Use a opção B<--help-format> para ver a lista de formatos disponíveis.

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.
pt: Ficheiro que contem o documento principal para traduzir. Pode usar esta opção várias vezes se quiser 'gettextize' vários documentos.

note: type: textblock
en: Charset of the file containing the document to translate.
pt: Conjunto de caracteres do ficheiro que contém o documento a traduzir.

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.
pt: Ficheiro que contem o documento localizado (traduzido). Se forneceu ficheiros mestres múltiplos, pode fornecer múltiplos ficheiros localizados a usar esta opção mais de uma vez.

note: type: textblock
en: Charset of the file containing the localized document.
pt: Conjunto de caracteres do ficheiro que contém o documento localizado.

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.
pt: Ficheiro onde o catálogo de mensagens deve ser escrito. Se não for dado, a mensagem catálogo será escrita na saída standard.

note: type: textblock
en: List the documentation formats understood by po4a.
pt: Lista os formatos de documentação compreendidos por 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.
pt: Mantém o mestre temporário e os ficheiros POT localizados criados antes da fusão. Isto pode servir para entender por que esses ficheiros são dessincronizados, o que leva a problemas de gettextização.

note: type: =head2
en: Converting a manual translation to po4a
pt: Converter a tradução manual para 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.
pt: B<po4a-gettextize> sincroniza os ficheiros mestres e localizados para extrair seu conteúdo num ficheiro PO. O conteúdo do ficheiro mestre fornece o B<msgid> enquanto o conteúdo do ficheiro localizado fornece o B<msgstr>. Este processo é um tanto frágil: supõe-se que a enésima cadeia do ficheiro traduzido seja a tradução da enésima cadeia no original.

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.
pt: A gettextização funciona melhor se conseguir recuperar a versão exata do documento original que foi usado para a tradução. Mesmo assim, pode precisar mexer com ficheiros mestres e localizados para alinhar a sua estrutura se foi alterado pelo tradutor original, então é aconselhado trabalhar em cópias de ficheiros.

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.
pt: Internamente, cada analisador do po4a relata o tipo sintático de cada cadeia extraída. É assim que a dessincronização é detetada durante a gettextização. No exemplo mostrado abaixo, é muito improvável que a quarta cadeia na tradução (do tipo "chapter") seja a tradução da quarta cadeia no original (do tipo "paragraph"). É mais provável que um novo parágrafo tenha sido adicionado ao original ou que dois parágrafos originais tenham sido fundidos na tradução.

note: type: verbatim
en:     Original         Translation
    
      chapter            chapter
        paragraph          paragraph
        paragraph          paragraph
        paragraph        chapter
      chapter              paragraph
        paragraph          paragraph
pt:     Original         Tradução
    
      capítulo            capítulo
        parágrafo           parágrafo
        parágrafo           parágrafo
        parágrafo         capítulo
      capítulo              parágrafo
        parágrafo           parágrafo

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.
pt: B<po4a-gettextize> irá diagnosticar detalhadamente qualquer dessincronização de estrutura. Quando isto acontece, deve editar manualmente os ficheiros para adicionar parágrafos falsos ou remover algum conteúdo aqui e ali, até que a estrutura dos dois ficheiros corresponda perfeitamente. Alguns truques são fornecidos abaixo para salvar o máximo da tradução existente ao fazer isto.

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.
pt: Se tiver a sorte de ter uma correspondência perfeita de primeira nas estruturas de ficheiro prontas, construir um ficheiro PO correto é uma questão de segundos. Caso contrário, logo perceberá por que este processo tem um nome tão feio :) Mesmo assim, a gettextização geralmente permanece mais rápida do que traduzir tudo novamente. Gettextifiquei a tradução francesa de toda a documentação do Perl num dia, apesar dos problemas de sincronização. Dada a quantidade de texto (2MB de texto original), reiniciar a tradução sem primeiro gravar as traduções antigas teria exigido vários meses de trabalho. Além disso, este trabalho pesado é o preço a pagar para obter o conforto do po4a. Uma vez convertido, a sincronização entre documentos mestre e traduções será sempre totalmente automática.

note: type: textblock
en: After a successful gettextization, the produced documents should be manually checked for undetected disparities and silent errors, as explained below.
pt: Após uma gettextização bem sucedida, os documentos produzidos devem ser verificados manualmente para disparidades não detetadas e erros silenciosos, como explicado abaixo.

note: type: =head3
en: Hints and tricks for the gettextization process
pt: Dicas e truques para o processo de gettextização

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.
pt: A gettextização pára assim que uma dessincronização é detetada. Quando isto acontece, deve editar os ficheiros o quanto for necessário para realinhar as estruturas dos ficheiros. B<po4a-gettextize> é bastante detalhado quando as coisas dão errado. Informa as cadeias que não correspondem, as suas posições no texto e o tipo de cada uma delas. Além disso, o ficheiro PO gerado até agora é descartado como F<gettextization.failed.po> para inspeção adicional.

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:
pt: Aqui estão alguns truques para ajudá-lo neste processo tedioso e garantir que salve o máximo da tradução anterior:

note: type: =item
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 addenda (see L<po4a(7)>).
pt: Remova todo o conteúdo extra das traduções, como a secção que dá créditos aos tradutores. Eles devem ser adicionados separadamente a B<po4a> como adendos (veja L<po4a(7)>).

note: type: =item
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.
pt: Ao editar os ficheiros para alinhar as suas estruturas, prefira editar a tradução se possível. Na verdade, se as alterações no original forem muito intrusivas, as versões antiga e nova não serão correspondidas durante a primeira execução do po4a após a gettextização (veja abaixo). Qualquer tradução sem correspondência será descartada de qualquer maneira. Dito isto, ainda deseja editar o documento original se for muito difícil fazer com que a gettextização prossiga de outra forma, mesmo que isso signifique que um parágrafo da tradução seja descartado. O importante é obter um primeiro ficheiro PO para começar.

note: type: =item
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.
pt: Não hesite em eliminar qualquer conteúdo original que não exista na versão traduzida. Este conteúdo será reintroduzido automaticamente posteriormente, ao sincronizar o ficheiro PO com o documento.

note: type: =item
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.
pt: Provavelmente deve informar o autor original de qualquer alteração estrutural na tradução que pareça justificada. Problemas no documento original devem ser relatadas ao autor. Corrigi-los na sua tradução os corrige apenas para uma parte da comunidade. Além disso, é impossível fazê-lo ao usar po4a ;) Mas provavelmente desejará esperar até o final da conversão para B<po4a> antes de alterar os ficheiros originais.

note: type: =item
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.
pt: Algumas vezes, o conteúdo do parágrafo corresponde, mas não os tipos deles. Corrigir isso é até dependente do formato. No POD e man, frequentemente vem do fato que um deles contém uma linha a começar com espaço em branco, mas a outra não.  Naqueles formatos tal parágrafo não pode ser dimensionado e, então, se torna um tipo diferente. Basta remover o espaço e está tudo bem. Pode também ser um erro de escrita no nome da marcação em 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.
pt: Da mesma forma, dois parágrafos podem ser fundidos juntamente num POD quando a linha separadora contém alguns espaços ou quando não há linha vazia entre a linha B<=item> e o conteúdo do item.

note: type: =item
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.
pt: Às vezes, a mensagem de dessincronização parece estranha porque a tradução está anexada ao parágrafo original errado. É o sinal de um problema não detetado no início do processo. Procure o ponto de dessincronização real inspecionando o ficheiro F<gettextization.failed.po> que foi produzido e corrija o problema onde ele realmente está.

note: type: =item
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.
pt: Outros problemas podem vir de cadeias duplicadas no original ou na tradução. Cadeias duplicadas são mescladas em ficheiros PO, com duas referências. Isto constitui uma dificuldade para o algoritmo de gettextização, que é um emparelhamento simples entre os B<msgid>s dos ficheiros mestre e localizado. No entanto, acredita-se que as versões recentes do po4a lidam adequadamente com cadeias duplicadas, portanto deve relatar qualquer problema remanescente que possa encontrar.

note: type: =head2
en: Reviewing files produced by B<po4a-gettextize>
pt: Rever ficheiros produzidos pelo 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.
pt: Qualquer ficheiro produzido pelo B<po4a-gettextize> deve ser revisado manualmente, mesmo quando o script tiver concluído com sucesso. Deve dar uma olhada no ficheiro PO, garantindo que B<msgid> e B<msgstr> realmente correspondam. Ainda não é necessário garantir que a tradução esteja perfeitamente correta, pois todas as entradas são marcadas como traduções difusas de qualquer maneira. Só precisa verificar se há problemas de correspondência óbvios, pois as traduções com correspondência incorreta serão descartadas nas etapas subsequentes enquanto deseja gravá-las.

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.
pt: Felizmente, esta etapa não requer o domínio dos idiomas de destino, pois deseja apenas reconhecer elementos semelhantes em cada B<msgid> e o seu B<msgstr> correspondente. Como falante de francês, inglês e um pouco de alemão, posso fazer isto pelo menos para todos os idiomas europeus, mesmo que não consiga dizer uma palavra da maioria desses idiomas. Às vezes consigo detetar problemas de correspondência em idiomas não latinos observando o comprimento das cadeias, as estruturas das frases (a quantidade de pontos de interrogação corresponde?) e outras pistas, mas prefiro quando outra pessoa pode revisar estes idiomas.

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.
pt: Se detetar uma incompatibilidade, edite os ficheiros originais e de tradução como se B<po4a-gettextize> tivesse relatado um erro e tente novamente. Depois de ter um ficheiro PO decente para a sua tradução anterior, faça salvaguarda dele até que o po4a funcione corretamente.

note: type: =head2
en: Running B<po4a> for the first time
pt: Executar B<po4a> pela primeira vez

note: type: textblock
en: The easiest way to setup po4a is to write a B<po4a.conf> configuration file, and use the integrated B<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.
pt: A maneira mais fácil de configurar o po4a é escrever um ficheiro de configuração B<po4a.conf> e usar o programa B<po4a> integrado (B<po4a-updatepo> e B<po4a-translate> foram descontinuados). Por favor, verifique a secção "ARQUIVO DE CONFIGURAÇÃO" na documentação do L<po4a(1)> para mais pormenores.

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.
pt: Quando B<po4a> for executado pela primeira vez, a versão atual dos documentos mestre será usada para atualizar os ficheiros PO contendo as traduções antigas que recuperou através da gettextização. Isto pode levar muito tempo, porque muitos dos B<msgid>s da gettextização não correspondem exatamente aos elementos do ficheiro POT criado a partir dos ficheiros mestres recentes. Isto força o gettext a procurar o mais próximo usando um algoritmo custoso de proximidade de cadeias. Por exemplo, a primeira execução da tradução francesa da documentação Perl (ficheiro PO de 5,5 MB) levou cerca de 48 horas (sim, dois dias), enquanto as subsequentes levaram apenas alguns segundos.

note: type: =head2
en: Moving your translations to production
pt: Mover as suas traduções para produção

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.
pt: Após esta primeira execução, os ficheiros PO estão prontos para serem revisados pelos tradutores. Todas as entradas foram marcadas como aproximadas (fuzzy) no ficheiro PO pelo B<po4a-gettextization>, forçando a sua revisão cuidadosa antes do uso. Os tradutores devem verificar cada entrada para verificar se a tradução recuperada realmente corresponde ao texto original atual, atualizar a tradução conforme necessário e remover as marcações de 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.
pt: Depois que marcadores de fuzzy suficientes forem removidos, B<po4a> começará a gerar os ficheiros de tradução no disco e estará pronto para mover o seu fluxo de trabalho de tradução para produção. Alguns projetos acham útil contar com o weblate para coordenação entre tradutores e mantenedores, mas isso está além do escopo do B<po4a>.

note: type: textblock
en: po4a-normalize - normalize a documentation file by parsing it in po4a, and writing it back
pt: po4a-normalize - normaliza um ficheiro de documentação ao analisa-lo em po4a e escrevê-lo de volta

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.
pt: O objetivo do projeto po4a (PO for anything: PO para qualquer coisa) é facilitar traduções (e o mais interessante, a manutenção das traduções) a usar as ferramentas do gettext em áreas em que não se esperava, como na documentação.

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.
pt: O script B<po4a-normalize> é uma ferramenta de depuração usada para se certificar de que o po4a não altera o documento quando não é suposto. Use-o apenas se estiver no desenvolvimento de um novo módulo, ou se duvidar da sanidade das ferramentas.

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.
pt: O documento gerado será escrito em F<po4a-normalize.output> enquanto o ficheiro POT gerado será escrito em F<po4a-normalize.po> por predefinição, mas pode usar as opções B<--localized> e B<--pot> para mudar isso.

note: type: textblock
en: Create a blank translated document.  The generated translated document will be generated assuming all messages are translated by a space or new line.
pt: Cria um documento em branco traduzido. O documento gerado traduzido vai ser gerado a assumir que todas as mensagens são traduzidas por um espaço ou nova linha.

note: type: textblock
en: This is useful to check what parts of the document cannot be translated.
pt: Isto é útil para verificar que partes do documento não podem ser traduzidas.

note: type: textblock
en: Both B<--blank> and B<--capitalize> can't be specified at the same time.
pt: B<--blank> e B<--capitalize> não podem ser especificados ao mesmo tempo.

note: type: textblock
en: Create a translated document and corresponding po-file with original strings translated as their capitalized versions.
pt: Cria um documento traduzido e o ficheiro po correspondente com as cadeias originais traduzidas como suas versões capitalizadas.

note: type: textblock
en: This is useful to check what parts of the document cannot be translated and generate test data for po4a.
pt: Isto é útil para verificar quais partes do documento não podem ser traduzidas e gerar dados de teste para o po4a.

note: type: textblock
en: Name of the normalized file to produce (I<po4a-normalize.output> by default).
pt: Nome do ficheiro normalizado para produzir (I<po4a-normalize.output> por predefinição).

note: type: textblock
en: Pot file to produce (I<po4a-normalize.po> by default).
pt: Ficheiro pot a ser produzido (I<po4a-normalize.po> por predefinição).

note: type: textblock
en: po4a-translate - convert a PO file back to documentation format
pt: po4a-translate - converter um ficheiro PO de volta ao formato de documentação

note: type: textblock
en: (I<XX.doc> is the output, all others are inputs)
pt: (I<XX.doc> é a saída, todos os outros são entradas)

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)>.
pt: O script B<po4a-translate> é responsável por converter a tradução (que foi feita num ficheiro PO) de volta para o formato de documentação. O ficheiro PO fornecido deverá ser a tradução do ficheiro POT que foi produzido por 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)>).
pt: Adicionar um ficheiro ao ficheiro resultante (para pôr o nome do tradutor ou uma secção "Sobre esta tradução", por exemplo). A primeira linha do ficheiro para inserção deve ser um cabeçalho PO4A a indicar onde ele deve ser adicionado (ver secção B<COMO adicionar texto extra para traduções> em L<po4a(7)>).

note: type: textblock
en: File containing the master document to translate.
pt: Ficheiro a conter o documento principal para traduzir.

note: type: textblock
en: File where the localized (translated) document should be written.
pt: Ficheiro onde o documento localizado (traduzido) deve ser escrito.

note: type: textblock
en: File from which the message catalog should be read.
pt: Ficheiro a partir do qual o catálogo de mensagens deve ser lido.

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.
pt: Limite mínimo de percentagem de tradução para manter (ou seja, escrever) o ficheiro resultante (predefinição: 80). Isto é, por predefinição, ficheiros têm que ser traduzidos a pelo menos 80% para serem escritos.

note: type: =head1
en: Adding content (beside translations) to generated files
pt: Adicionar conteúdo (além de traduções) para ficheiros gerados

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.
pt: Para adicionar algum conteúdo extra ao documento gerado além do que traduziu (como o nome do tradutor ou uma secção "Sobre essa tradução"), deve usar a opção 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.
pt: A primeira linha da adenda deve ser um cabeçalho a indicar onde colocá-lo no documento (que pode ser antes ou depois de uma determinada parte do documento). O resto do ficheiro será adicionado na íntegra para o ficheiro resultante sem processamento posterior.

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).
pt: Note que se po4a-translate não conseguir adicionar um dos ficheiros dados, ele descarta toda a tradução (porque o ficheiro que falta poderia ser o que indica o autor, o que impediria aos utilizadores o contato com ele para reportar erros na tradução).

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.
pt: O cabeçalho tem uma sintaxe bastante rígida. Para mais informações sobre como usar esse recurso e como ele funciona, consulte o manual do L<po4a(7)>.

note: type: textblock
en: po4a-updatepo - update the translation (in PO format) of documentation
pt: po4a-updatepo - atualiza a tradução de documentação (em formato PO)

note: type: textblock
en: (I<XX.po> are the outputs, all others are inputs)
pt: (I<XX.po> são as saídas, todos os outros são entradas)

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.
pt: O script B<po4a-updatepo> é encarregado de atualizar ficheiros PO para faze-los refletir as alterações feitas no ficheiro de documentação original. Para isso, converte o ficheiro de documentação num ficheiro POT e invoca L<msgmerge(1)> neste novo POT e nos ficheiros PO fornecidos.

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).
pt: É possível dar mais do que um ficheiro PO (se quiser atualizar vários idiomas de uma só vez) e alguns ficheiros de documentação (se deseja armazenar as traduções de diversos documentos no mesmo ficheiro 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.
pt: Se a documentação mestre possui caracteres não-ASCII, este script vai converter os ficheiros PO para UTF-8 (se eles não estiverem já), para uma manipulação transparente de caracteres não-standard.

note: type: textblock
en: File(s) containing the master document to translate.
pt: Ficheiro(s) que contêm o documento principal para traduzir.

note: type: textblock
en: Charset of the files containing the document to translate. Note that all files must have the same charset.
pt: Conjunto de caracteres dos ficheiros a conter o documento a traduzir. Note que todos os ficheiros devem ter o mesmo conjunto de caracteres.

note: type: textblock
en: PO file(s) to update. If these files do not exist, they are created by B<po4a-updatepo>.
pt: Ficheiro(s) PO para atualizar. Se esses ficheiros não existirem, são criados por 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).
pt: Esta opção remove B<--previous> das opções passadas ao B<msgmerge>. Isto ajuda a dar suporte a versões antigas do B<gettext> (anteriores ao v0.16).

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.
pt: O argumento pode ser seguido por uma vírgula ou pela palavra-chave B<wrap> ou B<nowrap>. Referências são escritas por predefinição numa única linha. A opção B<wrap> envolve referências sobre várias linhas, para imitar as ferramentas B<gettext> (B<xgettext> e B<msgmerge>). Esta opção irá tornar-se a predefinição num lançamento futuro, porque é mais sensível. A opção B<nowrap> é acessível aos utilizadores que querem manter o comportamento antigo.

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.
pt: Historicamente, o pacote gettext reformatou os ficheiros po na 77ª coluna para questões cosméticas. Esta opção especifica o comportamento de po4a. Se definido como um valor numérico, o po4a quebrará linha do ficheiro po após esta coluna e após novas linhas no conteúdo. Se definido como B<newlines>, o po4a dividirá apenas o msgid e o msgstr após as novas linhas no conteúdo. Se definido como B<no>, o po4a não quebrará linhas no ficheiro po. A quebra de linha dos comentários de referência é controlado pela opção B<--porefs>.

note: type: textblock
en: msguntypot - update PO files when a typo is fixed in POT file
pt: msguntypot - atualiza ficheiros PO quando um erro de digitação foi corrigido no ficheiro POT

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.
pt: Quando corrigir um erro trivial, que certamente não afeta as traduções (p.ex. um erro ortográfico) num ficheiro POT, deve retirar o fuzzy na mensagem traduzida correspondente nos ficheiros PO traduzidos para evitar o trabalho adicional para os tradutores.

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.
pt: Esta tarefa é difícil e sujeita a erros quando feita manualmente e esta ferramenta existe para ajudar a fazê-lo corretamente. Só precisa fornecer as duas versões do ficheiro POT: antes e depois da edição como marcado no resumo em cima, e tudo será automático.

note: type: =head1
en: HOW TO USE IT
pt: COMO USAR

note: type: textblock
en: In short, when you discover a typo in one of your [english] message, do the following:
pt: Resumindo, quando encontrar um erro de digitação numa das suas mensagens [Inglês], faça o seguinte:

note: type: =item
en: - Regenerate your POT and PO files.
pt: - Regenerar os seus ficheiros 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
pt:   make -C po/ update-po # para traduções de programas de mensagem
      debconf-updatepo      # para traduções debconf
      po4a po4a.conf        # para traduções de documentos de base 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??
pt: ou outra coisa, a depender das configurações de compilação do seu projeto. Sabe como certificar que os seus ficheiros POT e PO estão atualizados, não sabe??

note: type: =item
en: - Make a copy of your POT file.
pt: - Faça uma cópia do seu ficheiro POT.

note: type: =item
en: - Make a copy of all your PO files.
pt: - Faça uma cópia dos seus ficheiros PO.

note: type: =item
en: - Fix your typo.
pt: - Corrigir o seu erro de ortografia.

note: type: textblock
en: $EDITOR the_file_in_which_there_is_a_typo
pt: $EDITOR o_ficheiro_que_contém_um_erro_tipográfico

note: type: textblock
en: See above.
pt: Ver acima.

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.
pt: Neste ponto, o erro de digitação corrigido colocou em fuzzy todas as traduções, e esta lamentável mudança é a única entre os ficheiros PO do seu diretório principal e o congelado. Aqui está como resolver isso.

note: type: =item
en: - Discard fuzzy translation, restore the ones from the fridge.
pt: - Descartar tradução fuzzy, restaurar os que estão congelados.

note: type: =item
en: - Manually merge the PO files with the new POT file, but taking the useless fuzzy into account.
pt: - Manualmente fundir os ficheiros PO com o novo ficheiro POT, mas a tendo o fuzzy inútil em conta.

note: type: verbatim
en:   msguntypot -o myfile.pot.orig -n myfile.pot *.po
pt:   msguntypot -o meuficheiro.pot.orig -n meuficheiro.pot *.po

note: type: =item
en: - Cleanups.
pt: - Limpezas.

note: type: verbatim
en:   rm -rf myfile.pot.orig po_fridge
pt:   rm -rf meuficheiro.pot.orig po_fridge

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.
pt: Está feito. O erro de digitação foi erradicado das mensagens traduzidas de ambos os seus ficheiros POT e PO e os ficheiros PO não foram colocados em fuzzy no processo. Os seus tradutores já gostam de si.

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:
pt: Apesar do nome, esta ferramenta não é parte do conjunto de ferramentas gettext. Em vez disso é parte do po4a. Mais precisamente, é um script aleatório em Perl a usar módulos finos po4a. Para mais informações sobre po4a, consulte:

note: type: textblock
en: Copyright 2005 by SPI, inc.
pt: Direitos de Autor 2005 por SPI, inc.

note: type: textblock
en: po4a - framework to translate documentation and other materials
pt: po4a - infraestrutura para traduzir documentação e outros materiais

note: type: =head1
en: Introduction
pt: Introdução

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.
pt: po4a (PO for anything) facilita a manutenção da traduções de documentação a usar as ferramentas gettext clássicas. A característica principal do po4a é que dissocia a tradução do conteúdo da estrutura documental dele.

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.
pt: Este documento serve como uma introdução ao projeto po4a focado em potenciais utilizadores que considerem a possibilidade de usar essa ferramenta e no desejo curioso de perceber por que as coisas são como são.

note: type: =head1
en: Why po4a?
pt: Porquê o 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.
pt: A filosofia do Software Livre é fazer a tecnologia verdadeiramente disponível a todos. Mas o licenciamento não é a única consideração: software livre não traduzido é inútil para quem não fala inglês. Portanto, ainda temos algum trabalho a fazer para fazer o software disponível a todos.

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.
pt: Essa situação é bem compreendida pela maioria dos projetos e agora todos estão convencidos da necessidade de traduzir tudo. No entanto, as traduções reais representam um enorme esforço de muitas pessoas, prejudicadas por pequenas dificuldades técnicas.

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.
pt: Felizmente, o software Open Source é, na verdade, muito bem traduzido a usar o conjunto de ferramentas gettext. Essas ferramentas são usadas para extrair as cadeias a traduzir de um programa e apresentar as cadeias a traduzir num formato padronizado (chamado de ficheiros PO ou catálogos de tradução). Todo um ecossistema de ferramentas surgiu para ajudar os tradutores a realmente traduzir esses ficheiros PO. O resultado é então utilizado pela gettext em tempo de execução para exibir as mensagens traduzidas para os utilizadores finais.

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.
pt: Em relação à documentação, no entanto, a situação ainda é um pouco decepcionante.   No início, traduzir a documentação pode parecer mais fácil do que traduzir um programa, pois parece que apenas precisa copiar o ficheiro-fonte da documentação e começar a traduzir o conteúdo. No entanto, quando a documentação original é modificada, acompanhar as modificações rapidamente se transforma num pesadelo para os tradutores. Se realizada manualmente, esta tarefa é desagradável e propensa a erros.

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.
pt: Traduções desatualizadas geralmente são piores do que nenhuma tradução. Os utilizadores finais podem ser enganados pela documentação que descreve um comportamento antigo do programa. Além disso, eles não podem interagir diretamente com os mantenedores, pois não falam inglês. Além disso, o mantenedor não pode resolver o problema, pois não conhece todos os idiomas em que a documentação deles está traduzida. Essas dificuldades, muitas vezes causadas por ferramentas precárias, podem minar a motivação de tradutores voluntários, a agravar o problema ainda mais.

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>.
pt: B<O objetivo do projeto po4a é facilitar o trabalho dos tradutores de documentação>.   Em particular, torna as traduções de documentações I<possíveis de manter>.

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.
pt: A ideia é de reutilizar e adaptar a abordagem gettext a esse campo. Assim como o gettext, os textos são extraídos dos seus locais originais e apresentados aos tradutores como catálogos de tradução de pedidos. Os tradutores podem aproveitar as ferramentas gettext clássicas para monitorar o trabalho a realizar, colaborar e organizar em equipa. O po4a injeta as traduções diretamente na estrutura da documentação para produzir ficheiros de origem traduzidos que podem ser processados e distribuídos da mesma forma que os ficheiros em inglês. Qualquer parágrafo que não seja traduzido é deixado em inglês no documento resultante, a garantir que os utilizadores finais nunca vejam uma tradução desatualizada na documentação.

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.
pt: Isso automatiza a maior parte do trabalho pesado da manutenção da tradução. A descoberta dos parágrafos que precisam de atualização torna-se muito fácil e o processo é completamente automatizado quando os elementos são reordenados sem modificações adicionais. A verificação específica também pode ser usada para reduzir a hipótese de erros de formatação que resultariam num documento quebrado.

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.
pt: Por favor, consulte também o B<FAQ> abaixo neste documento para uma lista mais completa das vantagens e desvantagens desta abordagem.

note: type: =head2
en: Supported formats
pt: Formatos suportados

note: type: textblock
en: Currently, this approach has been successfully implemented to several kinds of text formatting formats:
pt: Atualmente, esta abordagem tem sido implementada com sucesso para vários tipos de formatos de formatação de texto:

note: type: =item
en: man (mature parser)
pt: man (analisador maduro)

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.
pt: O bom e velho formato de páginas de manual, usado por muitos programas por aí. O suporte ao po4a é muito bem-vindo pois este formato é de certa forma difícil de usar e realmente não amigável para novatos.

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).
pt: O módulo L<Locale::Po4a::Man(3pm)|Man> também possui suporte do formato mdoc usado pelas páginas man do BSD (elas também são bastante comuns no Linux).

note: type: =item
en: AsciiDoc (mature parser)
pt: AsciiDoc (analisador maduro)

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.
pt: Esse formato é um formato de markup leve, destinado a facilitar a criação da documentação. Por exemplo, é usado para documentar o sistema git. Essas páginas man são traduzidas usando po4a.

note: type: textblock
en: See L<Locale::Po4a::AsciiDoc> for details.
pt: Veja L<Locale::Po4a::AsciiDoc> para detalhes.

note: type: =item
en: pod (mature parser)
pt: pod (analisador maduro)

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.
pt: Este é o formato de Documentação Perl Online. A linguagem e as próprias extensões são documentadas a usar este formato, além da maioria dos scripts Perl existentes. Torna fácil manter a documentação perto do código real, a incorpora-los ambos no mesmo ficheiro. Torna a vida do programador mais fácil, mas infelizmente não a do tradutor, até que use o po4a.

note: type: textblock
en: See L<Locale::Po4a::Pod> for details.
pt: Veja L<Locale::Po4a::Pod> para detalhes.

note: type: =item
en: sgml (mature parser)
pt: sgml (analisador maduro)

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.
pt: Mesmo que hoje em dia seja substituído pelo XML, este formato ainda é utilizado para documentos com o comprimento de mais do que alguns ecrãs. Pode até mesmo ser usado para livros inteiros.  Pode ser muito desafiador de atualizar documentos deste tamanho. B<diff> frequentemente revela-se inútil quando o texto original foi reintroduzido após a atualização.  Felizmente, o po4a pode ajudá-lo após esse 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.
pt: Atualmente, apenas os DTD DebianDoc e DocBook são suportados, mas a acrescentar suporte para um novo é muito simples. É até possível usar po4a num SGML DTD desconhecido sem alterar o código, a fornecer as necessárias informações sobre a linha de comando. Veja L<Locale::Po4a::Sgml(3pm)> para mais detalhes.

note: type: =item
en: TeX / LaTeX (mature parser)
pt: TeX / LaTeX (analisador maduro)

note: type: textblock
en: The LaTeX format is a major documentation format used in the Free Software world and for publications.
pt: O formato LaTeX é o formato de documentação principal usado nas publicações de Software Livre mundiais.

note: type: textblock
en: The L<Locale::Po4a::LaTeX(3pm)|LaTeX> module was tested with the Python documentation, a book and some presentations.
pt: O módulo L<Locale::Po4a::LaTeX(3pm)|LaTeX> foi testado com a documentação Python, um livro e algumas apresentações.

note: type: =item
en: text (mature parser)
pt: text (analisador maduro)

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.
pt: O formato Text é o formato base para muitos formatos que incluem longos blocos de texto, incluindo Markdown, fortunes, secção de página de rotos YAML, 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.
pt: Este possui suporte do formato comum usado em geradores de sites estáticos, READMEs e outros sistemas de documentação. Consulte L<Locale::Po4a::Text(3pm)|Text> para detalhes.

note: type: =item
en: xml and XHMTL (probably mature parser)
pt: xml e XHMTL (analisador provavelmente maduro)

note: type: textblock
en: The XML format is a base format for many documentation formats.
pt: O formato XML é um formato base para muitos formatos de documentação.

note: type: textblock
en: Currently, the DocBook DTD (see L<Locale::Po4a::Docbook(3pm)> for details) and XHTML are supported by po4a.
pt: Atualmente, o DocBook DTD (veja L<Locale::Po4a::Docbook(3pm)> para detalhes) e o XHTML são suportados pelo po4a.

note: type: =item
en: BibTex (probably mature parser)
pt: BibTex (analisador provavelmente maduro)

note: type: textblock
en: The BibTex format is used alongside LaTex for formatting lists of references (bibliographies).
pt: O formato BibTex é usado junto com o LaTex para formatar listas de referências (bibliografias).

note: type: textblock
en: See L<Locale::Po4a::BibTex> for details.
pt: Veja L<Locale::Po4a::BibTex> para detalhes.

note: type: =item
en: Docbook (probably mature parser)
pt: Docbook (analisador provavelmente maduro)

note: type: textblock
en: A XML-based markup language that uses semantic tags to describe documents.
pt: Uma linguagem de marcação baseada em XML que usa etiquetas semânticas para descrever documentos.

note: type: textblock
en: See L<Locale::Po4a:Docbook> for greater details.
pt: Veja L<Locale::Po4a:Docbook> para mais detalhes.

note: type: =item
en: Guide XML (probably mature parser)
pt: Guide XML (analisador provavelmente maduro)

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.
pt: Um formato de documentação XML. Este módulo foi desenvolvido especificamente para ajudar no suporte e manutenção de traduções da documentação do Gentoo Linux até pelo menos março de 2016 (baseado na máquina Wayback). Desde então, o Gentoo mudou para o formato DevBook XML.

note: type: textblock
en: See L<Locale::Po4a:Guide> for greater details.
pt: Veja L<Locale::Po4a:Guide> para mais detalhes.

note: type: =item
en: Wml (probably mature parser)
pt: Wml (analisador provavelmente maduro)

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.
pt: A Web Markup Language, não confunda WML com o material WAP usado em telefones celulares. Este módulo depende do módulo Xhtml, que por sua vez depende do módulo XmL.

note: type: textblock
en: See L<Locale::Po4a::Wml> for greater details.
pt: Veja L<Locale::Po4a::Wml> para mais detalhes.

note: type: =item
en: Yaml (probably mature parser)
pt: Yaml (analisador provavelmente maduro)

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.
pt: Um superconjunto estrito de JSON. YAML é frequentemente usado como sistemas ou projetos de configuração. YAML está no núcleo do Ansible da Red Hat.

note: type: textblock
en: See L<Locale::Po4a::Yaml> for greater details.
pt: Veja L<Locale::Po4a::Yaml> para mais detalhes.

note: type: =item
en: RubyDoc (probably mature parser)
pt: RubyDoc (analisador provavelmente maduro)

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.
pt: O formato Ruby Document (RD), originalmente o formato de documentação padrão para Ruby e projetos Ruby antes de ser convertido para RDoc em 2002. Embora aparentemente a versão japonesa do Manual de Referência Ruby ainda use RD.

note: type: textblock
en: See L<Locale::Po4a::RubyDoc> for greater details.
pt: Veja L<Locale::Po4a::RubyDoc> para mais detalhes.

note: type: =item
en: Halibut (probably experimental parser)
pt: Halibut (analisador provavelmente experimental)

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.
pt: Um sistema de produção de documentação, com elementos semelhantes ao TeX, debiandoc-sgml, TeXinfo e outros, desenvolvido por Simon Tatham, o programador do PuTTY.

note: type: textblock
en: See L<Locale::Po4a:Halibut> for greater details.
pt: Veja L<Locale::Po4a:Halibut> para mais detalhes.

note: type: =item
en: Ini (probably experimental parser)
pt: Ini (analisador provavelmente experimental)

note: type: textblock
en: Configuration file format popularized by MS-DOS.
pt: Formato de ficheiro de configuração popularizado pelo MS-DOS.

note: type: textblock
en: See L<Locale::Po4a::Ini> for greater details.
pt: Veja L<Locale::Po4a::Ini> para mais detalhes.

note: type: =item
en: texinfo (very highly experimental parser)
pt: texinfo (analisador altamente experimental)

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.
pt: Toda a documentação GNU está escrita neste formato (ainda é um dos requisitos para um projeto GNU se tornar oficial). O apoio para L<Locale::Po4a::Texinfo(3pm)|Texinfo> em po4a ainda está no início. Por favor, reporte erros e solicitações de recursos.

note: type: =item
en: gemtext (very highly experimental parser)
pt: gemtext (analisador altamente experimental)

note: type: textblock
en: The native plain text format of the Gemini protocol.  The extension C<.gmi> is commonly used.  Support for this module in po4a is still in its infancy.  If you find anything, please file a bug or feature request.
pt: O formato de texto simples nativo do protocolo Gemini. A extensão C<.gmi> é comumente usada. O suporte para este módulo no po4a ainda está em estágio muito inicial. Se encontrar alguma coisa, registe um relatório de bug ou uma solicitação de recurso.

note: type: =item
en: org (very highly experimental parser)
pt: org (analisador altamente experimental)

note: type: textblock
en: The document format used by the Org mode.  Support for this module in po4a is still in its infancy.  If you find anything, please file a bug or feature request.
pt: O formato de documento usado pelo modo Org.  Apoio para este módulo em po4a continua na sua infância. Se encontrar alguma coisa, por favor crie um bug ou uma solicitação de recurso.

note: type: =item
en: vimhelp (very highly experimental parser)
pt: vimhelp (analisador altamente experimental)

note: type: textblock
en: The format used for Vim help files (and some third-party plugin documentation).  Support for this format in po4a is still in its infancy.  If you find anything, please file a bug report or feature request.
pt: O formato usado para ficheiros de ajuda do Vim (e alguma documentação do plugin de terceiros). O suporte para este formato em po4a ainda está na sua infância. Se encontrar algo, por favor envie um relatório de bug ou uma solicitação de recurso.

note: type: =item
en: simplepod (very highly experimental parser)
pt: simplepod (analisador altamente experimental)

note: type: textblock
en: Similar to the previously mentioned I<pod>, this one adopts the new L<Pod::Simple> as its parser.  Since it is newly created, some bugs are expected.  If you notice any strange behavior, please let us know.  Eventually, this module will replace I<pod>.
pt: Semelhante ao anteriormente mencionado I<pod>, este adota o novo L<Pod::Simple> como seu analisador.  Como é criação recente, são esperados alguns bugs.  Se você notar qualquer comportamento estranho, por favor diga-nos.  Eventualmente, este módulo irá substituir o I<pod>.

note: type: =item
en: Others supported formats
pt: Outros formatos suportados

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.
pt: Po4a também pode manipular alguns formatos mais raros ou especializados, como a documentação de opções de compilação dos kernels Linux 2.4+ (L<Locale::Po4a::KernelHelp>) ou diagramas produzidos pela ferramenta Dia (L<Locale::Po4a::Dia>). A adição de um novo formato é normalmente muito fácil e a tarefa principal é fazer um analisador para o seu formato alvo. Veja L<Locale::Po4a::TransTractor(3pm)> para mais informações sobre isto.

note: type: =item
en: Unsupported formats
pt: Formatos não suportados

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.
pt: Infelizmente, o po4a ainda carece suporte para vários formatos de documentação. Muitos deles facilmente seriam suportados pelo po4a. Isto inclui formatos não apenas usados para documentação, tais como, descrições de pacotes (deb e rpm), questões de scripts de instalação de pacotes, changelogs de pacotes e todos os formatos de ficheiros especializados usados por programas como cenários de jogos ou ficheiros de recursos do wine.

note: type: =head1
en: Using po4a
pt: Usar o po4a

note: type: textblock
en: The easiest way to use this tool in your project is to write a configuration file for the B<po4a> program, and only interact with this program. Please refer to its documentation, in L<po4a(1)>. The rest of this section provides more details for the advanced users of po4a wanting to deepen their understanding.
pt: A maneira mais fácil de usar esta ferramenta no seu projeto é escrever um ficheiro de configuração para o programa B<po4a> e interagir apenas com este programa. Consulte a sua documentação, em L<po4a(1)>. O restante desta secção fornece mais pormenores para os utilizadores avançados do po4a que desejam aprofundar a sua compreensão.

note: type: =head2
en: Detailed schema of the po4a workflow
pt: Esquema detalhado do fluxo de trabalho do po4a

note: type: textblock
en: Make sure to read L<po4a(1)> before this overly detailed section to get a simplified overview of the po4a workflow. Come back here when you want to get the full scary picture, with almost all details.
pt: Certifique-se de ler L<po4a(1)> antes desta secção excessivamente detalhada para obter uma visão geral simplificada do fluxo de trabalho do po4a. Volte aqui quando quiser ver a imagem assustadora completa, com quase todos os pormenores.

note: type: textblock
en: In the following schema, 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, etc); the translators will be mostly concerned with the PO file, while the end users will only see the F<XX.doc> file.
pt: No esquema a seguir, F<master.doc> é um nome de exemplo para a documentação a ser traduzida; F<XX.doc> é o mesmo documento traduzido no idioma XX, enquanto F<doc.XX.po> é o catálogo de traduções desse documento no idioma XX. Os autores da documentação se preocuparão principalmente com F<master.doc> (que pode ser uma página man, um documento XML, um ficheiro AsciiDoc etc.); os tradutores se preocuparão principalmente com o ficheiro PO, enquanto os utilizadores finais verão apenas o ficheiro F<XX.doc>.

note: type: textblock
en: Transitions with square brackets such as C<[po4a updates po]> represent the execution of a po4a tool while transitions with curly brackets such as C<{update of master.doc}> represent a manual modification of the project's files.
pt: Transições com parênteses retos, como C<[po4a atualiza po]>, representam a execução de uma ferramenta po4a, enquanto transições com chavetas, como C<{atualização do mestre.doc}>, representam uma modificação manual dos ficheiros do projeto.

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 updates po]                  |
              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 updates translations]
                                                      |
                                                      V
                                                    XX.doc
                                                 (up-to-date)
pt:                                    mestre.doc
                                           |
                                           V
         +<-----<----+<-----<-----<--------+------->-------->-------+
         :           |                     |                        :
     {tradução}      |        {atualização de mestre.doc}           :
         :           |                     |                        :
       XX.doc        |                     V                        V
     (opcional)      |                 mestre.doc ->-------->------>+
         :           |                  (novo)                      |
         V           V                     |                        |
      [po4a-gettextize]  doc.XX.po---->+   |                        |
              |           (velho)      |   |                        |
              |              ^         V   V                        |
              |              |    [po4a atualiza po]                |
              V              |           |                          V
         tradução.pot        ^           V                          |
              |              |       doc.XX.po                      |
              |              |       (incerto)                      |
         {tradução}          |           |                          |
              |              ^           V                          V
              |              |    {edição manual}                   |
              |              |           |                          |
              V              |           V                          V
          doc.XX.po --->---->+<---<-- doc.XX.po    adendo      mestre.doc
          (inicial)                 (atualizado)  (opcional)  (atualizado)
              :                          |            |             |
              :                          V            |             |
              +----->----->----->------> +            |             |
                                         |            |             |
                                         V            V             V
                                         +------>-----+------<------+
                                                      |
                                                      V
                                           [po4a atualiza traduções]
                                                      |
                                                      V
                                                    XX.doc
                                                (atualizado)

note: type: textblock
en: Again, this schema is overly complicated. Check on L<po4a(1)> for a simplified overview.
pt: Novamente, este esquema é excessivamente complicado. Confira L<po4a(1)> para uma visão geral simplificada.

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.
pt: A parte esquerda mostra como L<po4a-gettextize(1)> pode ser usado para converter um projeto de tradução existente para a infraestrutura do po4a. Este script leva um documento original e o equivalente traduzido e tenta construir o ficheiro PO correspondente. Tal conversão manual é um pouco trabalhosa (veja a documentação L<po4a-gettextize(1)> para mais detalhes), mas só é necessária uma vez para converter as suas traduções existentes. Se não tiver nenhuma tradução para converter, pode esquecer-se disto e focar-se na parte certa do esquema.

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 updates of translation files: 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.
pt: Na parte superior direita, a ação do autor original está descrita, atualização da documentação. A parte do meio, à direita, representa as atualizações automáticas dos ficheiros de tradução: os novos materiais são extraídos e comparados com a tradução existente. A tradução anterior é usada para as partes que não foram alteradas, enquanto partes parcialmente modificadas também são conectadas à tradução anterior com uma marcação "fuzzy" indicando que a tradução deve ser atualizada. Material novo ou muito modificado é deixado sem tradução.

note: type: textblock
en: Then, the I<manual editing> block 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.
pt: Então, o bloco I<edição manual> representa a ação dos tradutores, que modificam os ficheiro PO para fornecer traduções para toda cadeias e parágrafo originais. Isto pode ser feito usando um editor específico, como o B<Editor de Tradução do GNOME>, o B<Lokalize> do KDE ou B<poedit>, ou usando uma plataforma de localização online como o B<weblate> ou B<pootle>. O resultado da tradução é um conjunto de ficheiros PO, um por idioma. Consulte a documentação gettext para mais pormenores.

note: type: textblock
en: The bottom part of the figure shows how B<po4a> 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.
pt: A parte inferior da figura mostra como B<po4a> cria um documento fonte traduzido do documento original F<master.doc> e do catálogo de traduções F<doc.XX.po> que foram atualizados pelos tradutores. A estrutura do documento é reutilizada, enquanto o conteúdo original é substituído pela contraparte dele traduzida. Opcionalmente, um adendo pode ser usado para adicionar textos à tradução. Isso geralmente é usado para adicionar o nome do tradutor ao documento final. Veja abaixo os detalhes.

note: type: textblock
en: Upon invocation, B<po4a> updates both the translation files and the translated documentation files automatically.
pt: Após a invocação, B<po4a> atualiza automaticamente os ficheiros de tradução e os ficheiros de documentação traduzidos.

note: type: =head2
en: Starting a new translation project
pt: Iniciar um novo projeto de tradução

note: type: textblock
en: If you start from scratch, you just have to write a configuration file for po4a, and you are set.  The relevant templates are created for the missing files, allowing your contributors to translate your project to their language. Please refer to L<po4a(1)> for a quick start tutorial and for all details.
pt: Se começa do zero, basta escrever um ficheiro de configuração para po4a e pronto. Os modelos relevantes são criados para os ficheiros ausentes, permitindo que os seus colaboradores traduzam o seu projeto para o idioma deles. Consulte L<po4a(1)> para um tutorial de início rápido e para todos os pormenores.

note: type: textblock
en: If you have an existing translation, i.e. a documentation file that was translated manually, you can integrate its content in your po4a workflow using B<po4a-gettextize>. This task is a bit cumbersome (as described in the tool's manpage), but once your project is converted to po4a workflow, everything will be updated automatically.
pt: Se já possui uma tradução, ou seja, um ficheiro de documentação que foi traduzido manualmente, pode integrar o seu conteúdo no seu fluxo de trabalho po4a usando B<po4a-gettextize>. Esta tarefa é um pouco complicada (conforme descrito no manual da ferramenta), mas assim que o seu projeto for convertido para o fluxo de trabalho po4a, tudo será atualizado automaticamente.

note: type: =head2
en: Updating the translations and documents
pt: Atualizar as traduções e os documentos

note: type: textblock
en: Once setup, invoking B<po4a> is enough to update both the translation PO files and translated documents. You may pass the C<--no-translations> to B<po4a> to not update the translations (thus only updating the PO files) or C<--no-update> to not update the PO files (thus only updating the translations). This roughly corresponds to the individual B<po4a-updatepo> and B<po4a-translate> scripts which are now deprecated (see "Why are the individual scripts deprecated" in the FAQ below).
pt: Após a configuração, invocar B<po4a> é suficiente para atualizar os ficheiros PO de tradução e os documentos traduzidos. Pode passar o C<--no-translations> para B<po4a> para não atualizar as traduções (atualizando apenas os ficheiros PO) ou C<--no-update> para não atualizar os ficheiros PO (atualizando apenas as traduções). Isto corresponde aproximadamente aos scripts individuais B<po4a-updatepo> e B<po4a-translate> que agora foram descontinuados (veja "Por que os scripts individuais foram descontinuados" no FAQ abaixo).

note: type: =head2
en: Using addenda to add extra text to translations
pt: Usando adendos para adicionar textos às traduções

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.
pt: Adicionar novos textos à tradução é provavelmente a única coisa mais fácil a longo prazo quando traduz ficheiros manualmente :). Isso acontece quando deseja adicionar uma secção adicional ao documento traduzido, que não corresponde a nenhum conteúdo no documento original. O caso de uso clássico é dar mérito à equipa de tradução e indicar como relatar problemas específicos da tradução.

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.
pt: Com o po4a, é necessário especificar os ficheiros B<addendum>, que podem ser vistos conceitualmente como patches aplicados ao documento localizado após o processamento. Cada adendo deve ser fornecido como um ficheiro separado, cujo formato é, no entanto, muito diferente dos patches clássicos. A primeira linha é uma I<linha de cabeçalho>, a definir o ponto de inserção do adendo (com uma sintaxe infelizmente enigmática -- veja abaixo) enquanto o restante do ficheiro é adicionado literalmente na posição determinada.

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.
pt: A linha do cabeçalho deve começar com a cadeia B<PO4A-HEADER:>, seguida por uma lista separada por ponto e vírgula dos campos I<chave>B<=>I<valor>.

note: type: textblock
en: For example, the following header declares an addendum that must be placed at the very end of the translation.
pt: Por exemplo, o cabeçalho a seguir declara um adendo que deve ser posto bem no final da tradução.

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.
pt: As coisas ficam mais complexas quando deseja adicionar o seu conteúdo adicional no meio do documento. O cabeçalho a seguir declara um adendo que deve ser posto após a secção XML que contém a cadeia C<About this document> na tradução.

note: type: verbatim
en:  PO4A-HEADER: position=About this document; mode=after; endboundary=</section>
pt:  PO4A-HEADER: position=Acerca deste documento; mode=after; endboundary=</section>

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.
pt: Na prática, ao tentar aplicar um adendo, o po4a pesquisa a primeira linha correspondente ao argumento C<position> (isso pode ser um regexp). Não se esqueça que o po4a considera o documento B<translated> aqui. Esta documentação é em Inglês, mas a sua linha provavelmente deve ser a seguinte, se pretende que o seu adendo se aplique à tradução do documento em Francês.

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).
pt: Depois que a C<position> foi encontrada no documento de destino, o po4a procura a próxima linha após a C<position> que corresponde ao C<endboundary> fornecido. O adendo é adicionado à direita B<after> essa linha (porque fornecemos um I<endboundary>, ou seja, um limite que termina a secção atual).

note: type: textblock
en: The exact same effect could be obtained with the following header, that is equivalent:
pt: O exato mesmo efeito pode ser obtido com o cabeçalho seguinte, que é equivalente:

note: type: verbatim
en:  PO4A-HEADER: position=About this document; mode=after; beginboundary=<section>
pt:  PO4A-HEADER: position=Sobre este documento; mode=after; beginboundary=<section>

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 placing 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> >>.
pt: Aqui, o po4a pesquisa a primeira linha correspondente a C<< <section> >> após a linha correspondente a C<About this document> na tradução e adicione o adendo B<before> dessa linha, pois fornecemos um I<beginboundary>, ou seja, um limite que marca o início da próxima secção. Portanto, esta linha de cabeçalho exige a inserção do adendo após a secção que contém C<About this document> e instrui o po4a que uma secção começa com uma linha que contém a tag C<< <section> >>. Isto é equivalente ao exemplo anterior, porque o que realmente deseja é adicionar este adendo após C<< </section> >> ou antes de 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 is 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 is the last potential boundary line before the C<position>.
pt: Também pode definir a inserção I<modo> como o valor C<before>, com uma semântica semelhante: a combinação de C<mode=before> com um C<endboundary> porá o adendo apenas B<after> o limite correspondente, que é a última linha limite potencial antes da C<position>. Combinar C<mode=before> com um C<beginboundary> porá o adendo apenas B<before> do limite correspondente, que é a última linha limite potencial antes da 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
pt:   Modo   | Tipo de limite |       Limite usado         | Ponto de inserção am comparação ao limite
     ========|================|============================|==========================================
     'before'| 'endboundary'  | último antes de 'position' | Logo após o limite selecionado
     'before'|'beginboundary' | último antes de 'position' | Logo antes do limite selecionado
     'after' | 'endboundary'  |  primeiro após 'position'  | Logo após o limite selecionado
     'after' |'beginboundary' |  primeiro após 'position'  | Logo antes do limite selecionado
     'eof'   |   (none)       |  n/d                       | Fim do ficheiro

note: type: =head3
en: Hint and tricks about addenda
pt: Dicas e truques sobre adendos

note: type: =item
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$>.
pt: Lembre-se que estes são regexp. Por exemplo, se quiser combinar o final de uma secção nroff a terminar com a linha C<.fi>, não use C<.fi> como B<endboundary>, porque ele irá combinar com C<the[ fi]le>, que obviamente não é o que espera. O B<endboundary> correto, nesse caso, é: C<^\.fi$>.

note: type: =item
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.
pt: Espaços em branco SÃO importantes no conteúdo da C<position> e limites. Portanto, as duas linhas seguintes B<are different>. O segundo só será encontrado se houver espaços suficientes à direita no documento traduzido.

note: type: verbatim
en:  PO4A-HEADER: position=About this document; mode=after; beginboundary=<section>
     PO4A-HEADER: position=About this document ; mode=after; beginboundary=<section>
pt:  PO4A-HEADER: position=Acerca deste documento; mode=after; beginboundary=<section>
     PO4A-HEADER: position=Acerca deste documento ; mode=after; beginboundary=<section>

note: type: =item
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.
pt: Embora essa pesquisa de contexto possa ser considerada para operar cerca de cada linha do documento B<traduzido>, realmente opera na cadeia de dados interna do documento traduzido. Essa cadeia de dados interna pode ser um texto a abranger um parágrafo que contem várias linhas ou pode ser uma marcação XML sozinha. O exato I<ponto de inserção> do adendo deve ser anterior ou posterior à sequência de dados interna e não pode estar dentro da cadeia de dados interna.

note: type: =item
en: Pass the C<-vv> argument to B<po4a> to understand how the addenda are added to the translation. It may also help to run B<po4a> in debug mode to see the actual internal data string when your addendum does not apply.
pt: Passe o argumento C<-vv> para o B<po4a> para perceber como os adendos são adicionados à tradução. Também pode ajudar a executar B<po4a> no modo de depuração para ver a cadeia de dados interna real quando o seu adendo não se aplica.

note: type: =head3
en: Addenda examples
pt: Exemplos de adendos

note: type: =item
en: If you want to add something after the following nroff section:
pt: Se quiser acrescentar algo depois na secção seguinte nroff:

note: type: verbatim
en:   .SH "AUTHORS"
pt:   .SH "AUTORES"

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:
pt: Deve selecionar uma abordagem em duas etapas configurando B<mode=after>. Em seguida, deve restringir a pesquisa à linha após B<AUTHORS> com a regex de argumento B<position>. Então, deve combinar o início da próxima secção (isto é, B<^\.SH>) com a regex de argumento B<beginboundary>. É para dizer:

note: type: verbatim
en:  PO4A-HEADER:mode=after;position=AUTHORS;beginboundary=\.SH
pt:  PO4A-HEADER:mode=after;position=AUTORES;beginboundary=\.SH

note: type: =item
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.
pt: Se quiser adicionar algo logo após uma determinada linha (por exemplo, após a linha "Copyright Big Dude"), use uma B<position> a corresponder a esta linha, B<mode=after> e dê um B<beginboundary> a corresponder a qualquer linha.

note: type: =item
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.
pt: Se quiser adicionar alguma coisa no final do documento, dê uma B<position> correspondente a qualquer linha do seu documento (mas apenas uma linha, po4a não continuará se não é única) e dê uma B<endboundary> sem corresponder a nada. Aqui não use cadeias simples como B<"EOF">, mas prefira as que têm menos hipótese de estar no seu documento.

note: type: verbatim
en:  PO4A-HEADER:mode=after;position=About this document;beginboundary=FakePo4aBoundary
pt:  PO4A-HEADER:mode=after;position=Sobre este documento;beginboundary=FakePo4aBoundary

note: type: =head3
en: More detailed example
pt: Exemplo mais detalhado

note: type: textblock
en: Original document (POD formatted):
pt: Documento original (POD formatado):

note: type: verbatim
en:  |=head1 NAME
     |
     |dummy - a dummy program
     |
     |=head1 AUTHOR
     |
     |me
pt:  |=head1 NOME
     |
     |fictício - um programa fictício
     |
     |=head1 AUTOR
     |
     |eu

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").
pt: Então, a adenda a seguir irá garantir que uma secção (em francês) sobre o tradutor é adicionado no final do processo (em francês, "TRADUCTEUR" significa "TRADUTOR" e, "moi" significa "eu").

note: type: verbatim
en:  |PO4A-HEADER:mode=after;position=AUTEUR;beginboundary=^=head
     |
     |=head1 TRADUCTEUR
     |
     |moi
     |
pt:  |PO4A-HEADER:mode=after;position=AUTOR;beginboundary=^=head
     |
     |=head1 TRADUTOR
     |
     |eu
     |

note: type: textblock
en: To put your addendum before the AUTHOR, use the following header:
pt: Para posicionar a sua adenda antes do AUTOR, use o seguinte cabeçalho:

note: type: textblock
en: This works because the next line matching the B<beginboundary> C</^=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.
pt: Isto funciona porque a próxima linha correspondendo ao B<beginboundary> C</^=head1/> após a secção "NAME" (traduzido para "NOM" em Francês) é aquela declarando os autores. Então, o adendo será posto entre as duas secções. Note que se outra secção for adicionada entre as secções NAME e AUTHOR posteriormente, po4a porá o adendo equivocadamente antes da nova secção.

note: type: textblock
en: To avoid this you may accomplish the same using B<mode>=I<before>:
pt: Para evitar isto, pode realizar o mesmo a usar B<mode>=I<before>:

note: type: =head1
en: How does it work?
pt: Como é que funciona?

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 to maintain and to improve it. It may also help you to understand why it does not do what you expected, and how to solve your problems.
pt: Este capítulo dá a uma visão geral da parte interna do po4a, de forma que pode sentir-se mais confiante para nos ajudar a mantê-lo e melhorá-lo. Ele também pode ajudá-lo a perceber o porquê de ele não funcionar da forma que esperava e como resolver os seus problemas.

note: type: =head2
en: TransTractors and project architecture
pt: TransTractors e arquitetura do projeto

note: type: textblock
en: At the core of the po4a project, 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.
pt: No centro do projeto do po4a, a classe L<Locale::Po4a::TransTractor(3pm)|TransTractor> é um antepassado comum para todos analisadores do po4a. Este nome estranho vem do fato que ele é ao mesmo tempo o encarregado por tradução de documento e extração de cadeias.

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 as the input one, but with all translatable strings replaced with content of the input PO). Here is a graphical representation of this:
pt: Mais formalmente, ele leva um documento para traduzir mais um ficheiro PO contendo as traduções para usar como entrada, enquanto produz duas saídas separadas: outro ficheiro PO (resultante da extração das cadeias traduzíveis do documento de entrada) e um documento traduzido (com a mesma estrutura que a da entrada, mas com todas as cadeias traduzíveis substituídas com o conteúdo do PO de entrada). Aqui está uma representação gráfica disso:

note: type: verbatim
en:    Input document --\                             /---> Output document
                         \      TransTractor::       /       (translated)
                          +-->--   parse()  --------+
                         /                           \
       Input PO --------/                             \---> Output PO
                                                           (extracted)
pt:    Doc. de entrada --\                             /---> Doc. de saída
                          \      TransTractor::       /       (traduzido)
                           +-->--   parse()  --------+
                          /                           \
       PO de entrada ----/                             \---> PO de saída
                                                              (extraído)

note: type: textblock
en: This little bone is the core of all the po4a architecture. If you provide both input and disregard the output PO, you get B<po4a-translate>. If you disregard the output document instead, you get B<po4a-updatepo>. The B<po4a> uses a first TransTractor to get an up-to-date output POT file (disregarding the output documents), calls B<msgmerge -U> to update the translation PO files on disk, and builds a second TransTractor with these updated PO files to update the output documents. In short, B<po4a> provides one-stop solution to update what needs to be, using a single configuration file.
pt: Este ossinho é o núcleo de toda a arquitetura po4a. Se fornecer a entrada e desconsiderar o PO de saída, obterá B<po4a-translate>. Se desconsiderar o documento de saída, obterá B<po4a-updatepo>. O B<po4a> usa um primeiro TransTractor para obter um ficheiro POT de saída atualizado (desconsiderando os documentos de saída), chama B<msgmerge -U> para atualizar os ficheiros PO de tradução no disco e constrói um segundo TransTractor com estes ficheiros PO atualizados para atualizar os documentos de saída. Resumindo, B<po4a> fornece uma solução completa para atualizar o que precisa ser, usando um único ficheiro de configuração.

note: type: textblock
en: B<po4a-gettextize> also uses two TransTractors, but another way: It builds one TransTractor per language, and then build a new PO file using the msgids of the original document as msgids, and the msgids of the translated document as msgstrs. Much care is needed to ensure that the strings matched this way actually match, as described in L<po4a-gettextize(1)>.
pt: B<po4a-gettextize> também usa dois TransTractors, mas de outra forma: ele constrói um TransTractor por idioma e então constrói um novo ficheiro PO usando os msgids do documento original como msgids e os msgids do documento traduzido como msgstrs. É necessário muito cuidado para garantir que as cadeias correspondidas desta forma realmente correspondam, conforme descrito em L<po4a-gettextize(1)>.

note: type: =head2
en: Format-specific parsers
pt: Analisadores sintáticos específicos de formatos

note: type: textblock
en: All po4a format parsers are implemented on top of the TransTractor. Some of them are very simple, such as the Text, Markdown and AsciiDoc ones. They load the lines one by one using C<TransTractor::shiftline()>, accumulate the paragraphs' content or whatever. Once a string is completely parsed, the parser uses C<TransTractor::translate()> to (1) add this string to the output PO file and (2) get the translation from the input PO file. The parser then pushes the result to the output file using C<TransTractor::pushline()>.
pt: Todos os analisadores de formato po4a são implementados no TransTractor. Alguns deles são muito simples, como os Text, Markdown e AsciiDoc. Eles carregam as linhas uma por uma usando C<TransTractor::shiftline()>, acumulam o conteúdo dos parágrafos ou algo assim. Depois que uma cadeia é completamente analisada, o analisador usa C<TransTractor::translate()> para (1) adicionar esta cadeia ao ficheiro PO de saída e (2) obter a tradução do ficheiro PO de entrada. O analisador então envia o resultado para o ficheiro de saída usando C<TransTractor::pushline()>.

note: type: textblock
en: Some other parsers are more complex because they rely on an external parser to analyze the input document. The Xml, HTML, SGML and Pod parsers are built on top of SAX parsers. They declare callbacks to events such as "I found a new title which content is the following" to update the output document and output POT files according to the input content using C<TransTractor::translate()> and C<TransTractor::pushline()>. The Yaml parser is similar but different: it serializes a data structure produced by the YAML::Tiny parser. This is why the Yaml module of po4a fails to declare the reference lines: the location of each string in the input file is not kept by the parser, so we can only provide "$filename:1" as a string location. The SAX-oriented parsers use globals and other tricks to save the file name and line numbers of references.
pt: Alguns outros analisadores são mais complexos porque dependem de um analisador externo para analisar o documento de entrada. Os analisadores Xml, HTML, SGML e Pod são construídos com base nos analisadores SAX. Eles declaram retornos de chamada para eventos como "Encontrei um novo título cujo conteúdo é o seguinte" para atualizar o documento de saída e gerar ficheiros POT de acordo com o conteúdo de entrada usando C<TransTractor::translate()> e C<TransTractor::pushline()>. O analisador Yaml é semelhante, mas diferente: ele serializa uma estrutura de dados produzida pelo analisador YAML::Tiny. É por isso que o módulo Yaml do po4a falha ao declarar as linhas de referência: a localização de cada cadeia no ficheiro de entrada não é mantida pelo analisador, então só podemos fornecer "$filename:1" como localização da cadeia. Os analisadores orientados a SAX usam globais e outros truques para gravar o nome do ficheiro e os números de linha das referências.

note: type: textblock
en: One specific issue arises from file encodings and BOM markers. Simple parsers can forget about this issue, that is handled by C<TransTractor::read()> (used internally to get the lines of an input document), but the modules relying on an external parser must ensure that all files are read with an appropriate PerlIO decoding layer. The easiest is to open the file yourself, and provide an filehandle or directly the full string to your external parser. Check on C<Pod::read()> and C<Pod::parse()> for an example. The content read by the TransTractor is ignored, but a fresh filehandle is passed to the external parser. The important part is the C<< "<:encoding($charset)" >> mode that is passed to the B<open()> perl function.
pt: Um problema específico surge das codificações de ficheiros e dos marcadores BOM. Analisadores simples podem esquecer este problema, que é tratado por C<TransTractor::read()> (usado internamente para obter as linhas de um documento de entrada), mas os módulos que dependem de um analisador externo devem garantir que todos os ficheiros sejam lidos com uma camada de descodificação PerlIO apropriada. O mais fácil é abrir o ficheiro mesmo e fornecer um identificador de ficheiro ou diretamente a cadeia completa para o seu analisador externo. Verifique C<Pod::read()> e C<Pod::parse()> para obter um exemplo. O conteúdo lido pelo TransTractor é ignorado, mas um novo identificador de ficheiro é passado para o analisador externo. A parte importante é o modo C<< "<:encoding($charset)" >> que é passado para a função perl B<open()>.

note: type: =head2
en: Po objects
pt: Objetos PO

note: type: textblock
en: The L<Locale::Po4a::Po(3pm)|Po> class is in charge of loading and using PO and POT files. Basically, you can read a file, add entries, get translations with the B<gettext()> method, write the PO into a file. More advanced features such as merging a PO file against a POT file or validating a file are delegated to B<msgmerge> and B<msgfmt> respectively.
pt: A classe L<Locale::Po4a::Po(3pm)|Po> é responsável por carregar e utilizar ficheiros PO e POT. Basicamente, pode ler um ficheiro, adicionar entradas, obter traduções com o método B<gettext()>, gravar o PO num ficheiro. Recursos mais avançados, como mesclar um ficheiro PO com um ficheiro POT ou validar um ficheiro, são delegados a B<msgmerge> e B<msgfmt> respectivamente.

note: type: =head2
en: Contributing to po4a
pt: Contribuir para o po4a

note: type: textblock
en: Even if you have never contributed to any Open Source project in the past, you are welcome: we are willing to help and mentor you here. po4a is best maintained by its users nowadays. As we lack manpower, we try to make the project welcoming by improving the doc and the automatic tests to make you confident in contributing to the project. Please refer to the CONTRIBUTING.md file for more details.
pt: Mesmo que nunca tenha contribuído para nenhum projeto de código aberto no passado, é bem-vindo: estamos dispostos a ajudá-lo e orientá-lo aqui. po4a é melhor mantido pelos seus utilizadores hoje em dia. Como não temos mão de obra, procuramos tornar o projeto acolhedor melhorando a documentação e os testes automáticos para que tenha confiança em contribuir com o projeto. Consulte o ficheiro CONTRIBUTING.md para obter mais pormenores.

note: type: =head1
en: Open-source projects using po4a
pt: Projetos de código aberto que usam o 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).
pt: Aqui está uma lista bem parcial de projetos que usam po4a na produção para a documentação deles. Se quiser adicionar o seu projeto à lista, basta nos enviar um e-mail (ou um Pedido de Fusão).

note: type: =item
en: adduser (man): users and groups management tool.
pt: adduser (man): ferramenta de gestão de utilizadores e grupos.

note: type: =item
en: apt (man, docbook): Debian package manager.
pt: apt (man, docbook): Gestor de pacotes do Debian.

note: type: =item
en: aptitude (docbook, svg): terminal-based package manager for Debian
pt: aptitude (docbook, svg): Gestor de pacotes em interface de texto para Debian

note: type: =item
en: L<F-Droid website|https://gitlab.com/fdroid/fdroid-website> (markdown): installable catalog of FOSS (Free and Open Source Software) applications for the Android platform.
pt: L<F-Droid website|https://gitlab.com/fdroid/fdroid-website> (markdown): catálogo instalável de aplicações FOSS (abreviação de software livre e de código aberto) para a plataforma Android.

note: type: =item
en: L<git|https://github.com/jnavila/git-manpages-l10n> (asciidoc): distributed version-control system for tracking changes in source code.
pt: L<git|https://github.com/jnavila/git-manpages-l10n> (asciidoc): sistema de controle de versão distribuído para alterações de rastreamento em código-fonte.

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).
pt: Este projeto fornece uma infraestrutura para traduzir muitas páginas man para diferentes idiomas, prontas para integração em várias grandes distribuições (Arch Linux, Debian e derivados, Fedora).

note: type: =item
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.
pt: L<Stellarium|https://github.com/Stellarium/stellarium> (HTML): um planetário de código aberto e livre para o seu computador. po4a é usado para traduzir as descrições da cultura do céu.

note: type: =item
en: L<Jamulus|https://jamulus.io/> (markdown, yaml, HTML): a FOSS application for online jamming in real time. The website documentation is maintained in multiple languages using po4a.
pt: L<Jamulus|https://jamulus.io/> (markdown, yaml, HTML): um aplicação FOSS para jamming online em tempo real. A documentação do site é mantida em vários idiomas usando po4a.

note: type: =item
en: Other item to sort out: L<https://gitlab.com/fdroid/fdroid-website/> L<https://github.com/fsfe/reuse-docs/pull/61>
pt: Outro item para ordenar: L<https://gitlab.com/fdroid/fdroid-website/> L<https://github.com/fsfe/reuse-docs/pull/61>

note: type: =head1
en: FAQ
pt: PERGUNTAS MAIS FREQUENTES

note: type: =head2
en: How do you pronounce po4a?
pt: Como se 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 :)
pt: Pessoalmente vocalizo-o como L<pouah|https://en.wiktionary.org/wiki/pouah>, que é um onomatopaico francês que usamos no lugar de "eca" :) posso ter um senso de humor estranho :)

note: type: =head2
en: Why are the individual scripts deprecated?
pt: Por que os scripts individuais foram descontinuados?

note: type: textblock
en: Indeed, B<po4a-updatepo> and B<po4a-translate> are deprecated in favor of B<po4a>. The reason is that while B<po4a> can be used as a drop-in replacement to these scripts, there is quite a lot of code duplication here. Individual scripts last around 150 lines of codes while the B<po4a> program lasts 1200 lines, so they do a lot in addition of the common internals. The code duplication results in bugs occurring in both versions and needing two fixes. One example of such duplication are the bugs #1022216 in Debian and the issue #442 in GitHub that had the exact same fix, but one in B<po4a> and the other B<po4a-updatepo>.
pt: De fato, B<po4a-updatepo> e B<po4a-translate> foram descontinuados em favor de B<po4a>. A razão é que, embora B<po4a> possa ser usado como um substituto imediato para estes scripts, há muita duplicação de código aqui. Os scripts individuais duram cerca de 150 linhas de códigos, enquanto o programa B<po4a> dura 1200 linhas, então eles fazem muito além dos internos comuns. A duplicação de código resulta em bugs ocorrendo em ambas as versões e necessitando de duas correções. Um exemplo dessa duplicação são os bugs #1022216 no Debian e o issue #442 no GitHub que tiveram exatamente a mesma correção, mas um em B<po4a> e outro em B<po4a-updatepo>.

note: type: textblock
en: In the long run, I would like to drop the individual scripts and only maintain one version of this code. The sure thing is that the individual scripts will not get improved anymore, so only B<po4a> will get the new features. That being said, there is no deprecation urgency. I plan to keep the individual scripts as long as possible, and at least until 2030. If your project still use B<po4a-updatepo> and B<po4a-translate> in 2030, you may have a problem.
pt: No longo prazo, gostaria de descartar os scripts individuais e manter apenas uma versão deste código. O certo é que os scripts individuais não serão mais melhorados, então apenas B<po4a> receberá os novos recursos. Dito isto, não há urgência na remoção. Pretendo manter os scripts individuais pelo maior tempo possível e pelo menos até 2030. Se o seu projeto ainda usar B<po4a-updatepo> e B<po4a-translate> em 2030, pode ter um problema.

note: type: textblock
en: We may also remove the deprecation of these scripts at some point, if a refactoring reduces the code duplication to zero. If you have an idea (or better: a patch), your help is welcome.
pt: Também podemos remover a descontinuação desses scripts em algum momento, se uma refatoração reduzir a duplicação de código a zero. Se tem uma ideia (ou melhor: um patch), a sua ajuda é bem-vinda.

note: type: =head2
en: What about the other translation tools for documentation using gettext?
pt: E sobre as outras ferramentas de tradução para documentação a usar 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.
pt: Existem alguns deles. Aqui está uma lista possivelmente incompleta e mais ferramentas estão surgindo no horizonte.

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.
pt: Esta é a ferramenta desenvolvida por pessoas do KDE para lidar com DocBook XML. AFAIK, ele foi o primeiro programa para extrair cadeias para traduzir de documentação para ficheiros PO e injetá-las de volta depois da tradução.

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.
pt: Só pode lidar com XML e apenas um DTD particular. Estou muito descontente com a manipulação de listas, que terminam com um identificador de mensagem (msgid) grande. Quando a lista se torna enorme, o bloco torna-se mais difícil de absorver.

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.
pt: Este programa feito por Denis Barbier é uma espécie de precursor do módulo po4a SGML, que mais ou menos o descontinua. Como o nome diz, ele trata apenas o DebianDoc DTD, que é mais ou menos um DTD obsoleto.

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.
pt: Usado pela equipa de documentação do GIMP desde 2004, funciona muito bem mesmo que, como o nome sugere, apenas com ficheiros XML e precise de makefiles especialmente configurados.

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.
pt: O Projeto de Documentação Sphinx também usa gettext extensivamente para gerir as suas traduções. Infelizmente funciona apenas para alguns formatos de texto, rest e markdown, embora seja talvez a única ferramenta que faz isto a gerir todo o processo de tradução.

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.
pt: As principais vantagens de po4a sobre eles, são a facilidade de adição de conteúdos extra (que é pior ainda lá) e a capacidade de atingir gettextization.

note: type: =head2
en: SUMMARY of the advantages of the gettext based approach
pt: SUMÁRIO de vantagens da abordagem baseada em gettext

note: type: =item
en: The translations are not stored along with the original, which makes it possible to detect if translations become out of date.
pt: As traduções não são armazenadas com o original, o que torna possível detetar se as traduções estão desatualizadas.

note: type: =item
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.
pt: As traduções estão armazenadas em ficheiros separados a partir de cada um, o que previne os tradutores de idiomas diferentes de intervirem, em ambos, quando submetem os seus fragmentos (patches) e no nível do ficheiro codificado.

note: type: =item
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.
pt: É baseado em B<gettext> (mas B<po4a> oferece uma interface muito simples assim não precisa de compreender os internos para o usar). Dessa forma não precisamos de reinventar a roda e, porque o uso dele é mundial, podemos pensar que estas ferramentas estão mais ou menos livres de erros.

note: type: =item
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.
pt: Nada muda para o utilizador final (além do fato das traduções serem, como esperamos, melhor mantidas). O ficheiro de documentação resultante é exatamente o mesmo.

note: type: =item
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.
pt: Os tradutores não precisam de aprender a nova sintaxe de ficheiros e os editores de ficheiros PO favoritos deles (como o modo PO do Emacs, Lokalize ou Gtranslator) irão trabalhar bem.

note: type: =item
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:
pt: gettext oferece uma maneira simples de obter estatísticas acerca do que é feito, o que deveria ser revisto e atualizado e, o que ainda está por fazer. Alguns exemplos encontram-se nestes endereços:

note: type: textblock
en: But everything isn't green, and this approach also has some disadvantages we have to deal with.
pt: Mas não é tudo verde e, esta aproximação tem também algumas desvantagens com que temos de lidar.

note: type: =item
en: Addenda are somewhat strange at the first glance.
pt: Os adendos são um pouco estranhos à primeira vista.

note: type: =item
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.
pt: Não pode adaptar o texto traduzido as suas preferências, como a dividir um parágrafo aqui e, a juntar outros dois ali. Mas em certo sentido, se existe um problema com o original, deve ser reportado como um erro de qualquer maneira.

note: type: =item
en: Even with an easy interface, it remains a new tool people have to learn.
pt: Mesmo com um interface fácil, continua a ser ferramenta nova que as pessoas têm que aprender.

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.
pt: Um dos meus sonhos seria integrar de alguma forma po4a ao Gtranslator ou Lokalize. Quando um ficheiro de documento fosse aberto, as cadeias seriam automaticamente extraídas e um ficheiro traduzido + ficheiro po poderia ser gravado no disco. Se conseguirmos fazer um módulo para MS Word (TM) (ou pelo menos RTF), tradutores profissionais podem até mesmo usá-lo.

note: type: =item
en: The documentation of the all-in-one tool that you should use: L<po4a(1)>.
pt: A documentação da ferramenta multifuncional que deve usar: L<po4a(1)>.

note: type: =item
en: The documentation of the individual po4a scripts: L<po4a-gettextize(1)>, L<po4a-updatepo(1)>, L<po4a-translate(1)>, L<po4a-normalize(1)>.
pt: A documentação dos scripts individuais do po4a: L<po4a-gettextize(1)>, L<po4a-updatepo(1)>, L<po4a-translate(1)>, L<po4a-normalize(1)>.

note: type: =item
en: The additional helping scripts: L<msguntypot(1)>, L<po4a-display-man(1)>, L<po4a-display-pod(1)>.
pt: Os scripts de ajuda adicionais: L<msguntypot(1)>, L<po4a-display-man(1)>, L<po4a-display-pod(1)>.

note: type: =item
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.
pt: A implementação da infraestrutura principal: L<Locale::Po4a::TransTractor(3pm)> (particularmente importante para entender a organização do código), L<Locale::Po4a::Chooser(3pm)>, L<Locale::Po4a::Po(3pm)>, L<Locale::Po4a::Common(3pm)>. Por favor, verifique também o ficheiro F<CONTRIBUTING.md> na árvore fonte.

note: type: textblock
en: Locale::Po4a::AsciiDoc - convert AsciiDoc documents from/to PO files
pt: Locale::Po4a::AsciiDoc - converte documentos AsciiDoc de/para ficheiros PO

note: type: textblock
en: Locale::Po4a::AsciiDoc is a module to help the translation of documentation in the AsciiDoc format.
pt: Locale::Po4a::AsciiDoc é um módulo para ajudar a tradução de documentação no formato AsciiDoc.

note: type: =head1
en: OPTIONS ACCEPTED BY THIS MODULE
pt: OPÇÕES ACEITES POR ESTE MÓDULO

note: type: textblock
en: These are this module's particular options:
pt: Estas são as opções particulares deste módulo:

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.
pt: O nome de um ficheiro que contém as definições para po4a, como definido na secção B<INLINE CUSTOMIZATION>. Pode usar esta opção se não é possível pôr as definições no documento a ser traduzido.

note: type: textblock
en: In a definitions file, lines must not start by two slashes, but directly by B<po4a:>.
pt: Num ficheiro de definições, as linhas não podem começar com duas barras e sim diretamente pelo B<po4a:>.

note: type: textblock
en: Space-separated list of attribute entries you want to translate.  By default, no attribute entries are translatable.
pt: Lista separada por espaços das entradas de atributos que deseja traduzir.  Por predefinição, nenhuma entrada de atributo é traduzida.

note: type: textblock
en: Space-separated list of macro definitions.
pt: Lista separada por espaço das definições de macro.

note: type: textblock
en: Space-separated list of style definitions.
pt: Lista separada por espaço das definições de estilos.

note: type: textblock
en: Enable automatic line wrapping in non-verbatim blocks, even if the result could be misinterpreted by AsciiDoc formatters.
pt: Ativar a quebra de linha automática em blocos não verbais, mesmo que o resultado possa ser mal interpretado pelos formatadores 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:
pt: Por predefinição, o po4a não quebra os ficheiros AsciiDoc produzidos, porque uma inspeção manual é necessária para garantir que a quebra não altera a formatação. Considere, por exemplo, o seguinte item da lista:

note: type: verbatim
en:  * a long sentence that is ending with a number 1. A second sentence.
pt:  * uma frase comprida, que termina com um número 1. Uma segunda 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.
pt: Se este envolver levar à seguinte apresentação, o item é dividido numa sub-lista numerada. Para piorar a situação, apenas os falantes do idioma utilizado na tradução podem inspecionar a situação.

note: type: verbatim
en:  * a long sentence that is ending with a number
       1. A second sentence.
pt:  * uma frase comprida que termina com um número
       1. Uma segunda 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.
pt: Note que não embrulhar os ficheiros produzidos pelo po4a não deve ser um problema, uma vez que esses ficheiros devem ser processados automaticamente.  Eles não devem ser considerados como ficheiros fonte de qualquer forma.

note: type: textblock
en: With this option, po4a will produce better-looking AsciiDoc files, but it may lead to possibly erroneous formatted outputs.
pt: Com esta opção, o po4a produzirá ficheiros AsciiDoc mais apresentáveis, mas pode levar a saídas com formatação possivelmente errônea.

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.
pt: Por predefinição, os alvos das imagens de bloco são traduzíveis para dar oportunidade de fazer com que o conteúdo aponte para imagens traduzidas. Isso pode ser impedido ao configurar esta opção.

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.
pt: Esta opção é um sinalizador que permite a segmentação de sub-tabelas em conteúdo das células.  A segmentação é limitada ao conteúdo da célula, sem qualquer análise dentro dele.

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.
pt: Muda as regras de análise para compatibilidade com ferramentas diferentes. As opções disponíveis são "asciidoc" ou "asciidoctor". O Asciidoctor possui regras de análise mais rígidas, como a igualdade do comprimento das aberturas dos blocos de abertura e fecho.

note: type: textblock
en: Disable linting messages. When the source code cannot be fixed for clearer document structure, these messages are useless.
pt: Desativa mensagens em fiapos. Quando o código-fonte não pode ser corrigido para uma estrutura de documento mais clara, essas mensagens são inúteis.

note: type: textblock
en: Remove extra spaces from the source segments in no-wrap mode. This is useful when the translation tools are sensitive to the number of spaces.
pt: Remove espaços extras dos segmentos da fonte no modo no-wrap. Isto é útil quando as ferramentas de tradução são sensíveis ao número de espaços.

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.
pt: Lista separada por vírgula de chaves para processar para tradução na secção YAML Front Matter. Todas as outras chaves são ignoradas. As chaves são combinadas com uma correspondência que diferencia maiúsculas de minúsculas. Se B<yfm_paths> e B<yfm_keys> forem usadas juntas, os valores serão incluídos se forem correspondidos por pelo menos uma das opções. Os valores das matrizes sempre são traduzidos, a menos que a opção B<yfm_skip_array> seja fornecida.

note: type: textblock
en: Do not translate array values in the YAML Front Matter section.
pt: Não traduz os valores de vetor na secção YAML Front Matter.

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.
pt: Lista separada por vírgulas de caminhos hash para processar para extração na secção YAML Front Matter; todos os outros caminhos são ignorados. Os caminhos são combinados com uma correspondência que diferencia maiúsculas de minúsculas. Se B<yfm_paths> e B<yfm_keys> forem usadas juntas, os valores serão incluídos se forem correspondidos por pelo menos uma das opções. Os valores das matrizes sempre são retornados, a menos que a opção B<yfm_skip_array> seja fornecida.

note: type: =head1
en: INLINE CUSTOMIZATION
pt: PERSONALIZAÇÃO EM LINHA

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:
pt: O módulo AsciiDoc pode ser personalizado com linhas a começar com B<//po4a:>. Estas linhas são interpretadas como comandos para analisar. Os seguintes comandos são reconhecidos:

note: type: =item
en: B<//po4a: macro >I<name>B<[>I<attribute list>B<]>
pt: B<//po4a: macro >I<nome>B<[>I<lista de atributos>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.
pt: Isso descreve em detalhe os parâmetros de uma B<macro>; I<nome> deve ser um nome de macro válida e termina com um sublinhado se o alvo deve ser traduzido.

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.
pt: O argumento I<lista de argumentos> é uma lista separada por vírgulas que contém informações sobre argumentos traduzíveis. Esta lista contém números, para definir parâmetros posicionais, ou atributos nomeados.

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.
pt: Se um sinal de mais (B<+>) é prefixado ao I<nome>, então a macro e os argumentos dele são traduzidos como um todo. Não há necessidade de definir uma lista de atributos neste caso, mas colchetes devem estar presentes.

note: type: =item
en: B<//po4a: style >B<[>I<attribute list>B<]>
pt: B<//po4a: style >B<[>I<lista de atributos>B<]>

note: type: textblock
en: This describes in detail which attributes of a style must be translated.
pt: Isso descreve em detalhe quais atributos de um estilo devem ser traduzidos.

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.
pt: O argumento I<lista de atributos> é uma lista separada por vírgulas que contém informações sobre argumentos traduzíveis. Esta lista contém números, para definir parâmetros posicionais, ou atributos nomeados. O primeiro atributo é o nome do estilo e não será traduzido.

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.
pt: Se um sinal de mais (B<+>) for prefixado ao nome do estilo, então a lista de atributos é traduzida como um todo. Não há necessidade de definir atributos traduzíveis.

note: type: textblock
en: If a minus sign (B<->) is prepended to the style name, then this attribute is not translated.
pt: Se um sinal de menos (B<->) for prefixado ao nome do estilo, então este atributo não é traduzido.

note: type: textblock
en: If a percent signe (B<%>) is appended to the style name, then the style is processed as verbatim. The lines in paragraph or block of such style are preserved in the po files and the corresponding entries are marked as no-wrap.
pt: Se um sinal de percentagem (B<%>) for acrescentado ao nome do estilo, então o estilo é processado como literalmente. As linhas em parágrafo ou bloco de tal estilo são apresentadas nos ficheiros po e as entras correspondentes são marcadas como no-wrap.

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

note: type: textblock
en: This declares an attribute entry as being translatable.  By default, they are not translated.
pt: Isso declara uma entrada de atributo como sendo traduzível. Por predefinição não estão traduzidos.

note: type: =head1
en: STATUS OF THIS MODULE
pt: ESTADO DESTE MÓDULO

note: type: textblock
en: Tested successfully on simple AsciiDoc files.
pt: Testado com sucesso em ficheiros AsciiDoc simples.

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>.
pt:  Copyright © 2005-2008 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
     Copyright © 2012 Denis BARBIER <barbier@linuxfr.org>.
     Copyright © 2017 Martin Quinson <mquinson@debian.org>.

note: type: textblock
en: Locale::Po4a::BibTeX - convert BibTeX documents from/to PO files
pt: Locale::Po4a::BibTeX - converter documentos BibTeX de/para ficheiros 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.
pt: Locale::Po4a::BibTeX é um módulo para ajudar na tradução de bibliografias no formato BibTeX em outras línguas [humanas].

note: type: textblock
en: Fields values are extracted and proposed for translation.
pt: Valores de campos são extraídos e propostos para tradução.

note: type: textblock
en: NONE.
pt: NENHUM.

note: type: textblock
en: It is a very simple module, but still young.
pt: É um módulo muito simples, mas ainda jovem.

note: type: textblock
en: Locale::Po4a::Chooser - manage po4a modules
pt: Local::Po4a::Chooser - gere módulos 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.
pt: Locale::Po4a::Chooser é um módulo para gerir módulos do po4a. Anteriormente, todos os executáveis do po4a conheciam todos os módulos do po4a (pod, man, sgml, etc). Isso tornou chato adicionar um novo módulo, por ter de certificar que a documentação está sincronizada em todos os módulos e que cada um deles tenha acesso ao novo módulo.

note: type: textblock
en: Now, you just have to call the Locale::Po4a::Chooser::new() function, passing the name of module as argument.
pt: Agora, só tem que invocar o Locale::Po4a::Chooser::new() função, passando o nome do módulo como argumento.

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.
pt: A função Locale::Po4a::Chooser::list() lista os formatos disponíveis e sai com o valor passado como argumento. Portanto, chamamos Locale::Po4a::Chooser::list(0) quando solicitarmos a lista de formatos e Locale::Po4a::Chooser::list(1) quando passarmos um nome de formato inválido.

note: type: =item
en: About po4a:
pt: Acerca do po4a:

note: type: =item
en: About modules:
pt: Acerca de módulos:

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

note: type: textblock
en: Locale::Po4a::Common - common parts of the po4a scripts and utils
pt: Locale::Po4a::Commom - partes comuns dos scripts po4a e utilitários

note: type: textblock
en: Locale::Po4a::Common contains common parts of the po4a scripts and some useful functions used along the other modules.
pt: Locale::Po4a::Commom contém partes comuns dos scripts po4a e algumas funções úteis utilizadas ao longo dos outros módulos.

note: type: textblock
en: If needed, you can disable the use of Text::WrapI18N as such:
pt: Se necessário, pode desativar o uso de Text::WrapI18N da seguinte forma:

note: type: textblock
en: instead of:
pt: em vez de:

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.
pt: O pedido é importante aqui: como a maioria dos módulos Locale::Po4a carregam-se Locale::Po4a::Common, a primeira vez que este módulo é carregado determina se Text::WrapI18N é usado.

note: type: =head1
en: FUNCTIONS
pt: FUNÇÕES

note: type: =head2
en: Showing output messages
pt: Mostrando mensagens de saída

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.
pt: Mostra a versão atual do script e uma curta mensagem de direitos de autor. Recebe o nome do script como um argumento.

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.
pt: Esta função exibe uma mensagem da mesma forma que o sprintf(), mas dimensiona o resultado de forma que fique bonito no terminal.

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.
pt: Esta função funciona como wrap_msg(), mas leva um nome de módulo como o primeiro argumento e deixa um espaço no lado esquerdo da mensagem.

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.
pt: Esta função funciona como wrap_msg(), mas é preciso dum file:line referente como primeiro argumento, um nome de módulo como o segundo e deixa um espaço à esquerda da mensagem.

note: type: =head2
en: Wrappers for other modules
pt: Invólucros para outros módulos

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.
pt: Quando o módulo Locale::Gettext não pode ser carregado, este módulo fornece uma aplicação 'dummy' (vazio) das seguintes funções. Nesse caso, as mensagens po4a não serão traduzidas, mas o programa vai continuar a trabalhar.

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.
pt: Se Locale::gettext está presente, este invólucro também chama setlocale(LC_MESSAGES, "") assim os chamadores não dependem também do módulo POSIX.

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

note: type: textblock
en: Locale::Po4a::Dia - convert uncompressed Dia diagrams from/to PO files
pt: Locale::Po4a::Dia - converte diagramas Dia descompactados de/para ficheiros 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.
pt: Locale::Po4a::Dia é um módulo para ajudar a tradução de diagramas em formato Dia descompactado em outras línguas [humanas].

note: type: verbatim
en: You can get Dia (the graphical editor for these diagrams) from:
      http://www.gnome.org/projects/dia/
pt: Pode obter Dia (o editor gráfico para estes diagramas) em:
      http://www.gnome.org/projects/dia/

note: type: =head1
en: TRANSLATING WITH PO4A::DIA
pt: TRADUZINDO COM 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.
pt: Este módulo traduz apenas diagramas descompactados do Dia. Pode gravar os seus diagramas descompactados com o próprio Dia, a desmarcar o diálogo "Ficheiros de diagramas compactados" em "Gravar Diagrama".

note: type: verbatim
en: Another way is to uncompress the dia files from command line with:
      gunzip < original.dia > uncompressed.dia
pt: Outra forma para descompactar os ficheiros dia é através da linha de comandos com:
      gunzip <original.dia > uncompressed.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.
pt: Este módulo é totalmente funcional, uma vez que depende do módulo L<Locale::Po4a::Xml>. Este módulo apenas define as etiquetas traduzíveis (E<lt>dia:stringE<gt>) e filtra as cadeias internas (o conteúdo da etiqueta E<lt>dia:diagramdataE<gt> não é interessante para a tradução.

note: type: textblock
en: Locale::Po4a::Docbook - convert DocBook XML documents from/to PO files
pt: Locale::Po4a::Docbook - converter documentos DocBook XML de/para ficheiros PO

note: type: textblock
en: Locale::Po4a::Docbook is a module to help the translation of DocBook XML documents into other [human] languages.
pt: Locale::Po4a::Docbook é um módulo para ajudar a tradução de documentos DocBook XML em outras línguas [humanas].

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.
pt: Este módulo é totalmente funcional, uma vez que depende do módulo L<Locale::Po4a::Xml>. Isso só define as etiquetas e atributos traduzíveis.

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.
pt: O único problema conhecido é que ele ainda não manipula entidades e este inclui as entidades de inclusão de ficheiros, mas pode traduzir sozinho a maioria destes ficheiros (exceto os ficheiros de entidades típicas), e é geralmente melhor mantê-los separados.

note: type: =head2
en: OVERRIDE THE DEFAULT BEHAVIOR WITH COMMAND LINE OPTIONS
pt: SOBREPOR O COMPORTAMENTO PREDEFINIDO COM AS OPÇÕES DE LINHA DE COMANDO

note: type: textblock
en: The default behavior of system provided modules is set to be on the safe side.
pt: O comportamento predefinido dos módulos fornecidos pelo sistema é configurado para estar no lado seguro.

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.
pt: Por exemplo, a predefinição da etiqueta B<< <author> >> está a apontar para aparecer em B<< <para> >>. Mas pode estar a usar apenas em B<< <bookinfo> >>. Para este caso, pode traduzi-lo independentemente para cada autor.

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:
pt: Se não gostar do comportamento predefinido do módulo xml e os módulos derivados dele, poderá fornecer opções de linha de comando para alterar o comportamento deles. Por exemplo, pode adicionar o seguinte ao ficheiro de configuração po4a:

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.
pt: Isto substitui o comportamento predefinido para B<< <bookinfo> >> e B<< <author> >>, define B<< <bookinfo> >> e B<< <author> >> para interromper o fluxo de dados de entrada nessas etiquetas , define B<< <bookinfo> >> para não traduzir o conteúdo marcado dele e define B<< <author> >> para traduzir o conteúdo marcado dele.

note: type: textblock
en: Locale::Po4a::Gemtext - convert Gemtext documents from/to PO files.
pt: Locale::Po4a::Gemtext - converte documentos Gemtext de/para ficheiros PO.

note: type: textblock
en: Locale::Po4a::Gemtext is a module to help the translation of Gemtext documents into other [human] languages.
pt: Locale::Po4a::Gemtext é um módulo para ajudar na tradução de documentos Gemtext para outros idiomas [humanos].

note: type: textblock
en: Tested successfully on simple Gemtext files, such as the official Gemtext documentation.
pt: Testado com sucesso em ficheiros Gemtext, tal como a documentação oficial do Gemtext.

note: type: textblock
en: Locale::Po4a::Guide - convert Guide XML documents from/to PO files
pt: Locale::Po4a::Guide - converter documentos XML Guia de/para ficheiros 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.
pt: Locale::Po4a::Guide é um módulo para ajudar na tradução da documentação de Gentoo Linux no formato XML Guide em outras línguas [humanas].

note: type: textblock
en: This format is documented here: http://www.gentoo.org/doc/en/xml-guide.xml
pt: Este formato é documentado aqui: http://www.gentoo.org/doc/en/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.
pt: O único problema conhecido é que ele não inclui ficheiros com a etiqueta <include href = " ... "> , mas pode traduzir todos os ficheiros sozinho e é geralmente melhor mantê-los separados.

note: type: textblock
en: Locale::Po4a::Halibut - convert Halibut documents and derivates from/to PO files
pt: Locale::Po4a::Halibut - converte documentos Halibut e derivados de/para ficheiros PO

note: type: textblock
en: Locale::Po4a::Halibut is a module to help the translation of Halibut documents into other [human] languages.
pt: Locale::Po4a::Halibut é um módulo para ajudar a tradução de documentos Halibut em outras línguas [humanas].

note: type: textblock
en: This module contains the definitions of common Halibut commands and environments.
pt: Este módulo contém as definições dos comandos e ambientes comuns de Halibut.

note: type: textblock
en: This module is still beta.  Please send feedback and feature requests.
pt: Este módulo ainda está em beta.   Por favor, envie comentários e solicitações de recursos.

note: type: textblock
en: Some constructs are badly supported. The known ones are documented below.
pt: Algumas construções são mal suportadas. Os conhecidos estão documentados em baixo.

note: type: =head2
en: Verbatim blocks
pt: Blocos literais

note: type: textblock
en: The verbatim block is not considered as a whole. Each line will be translated separately.
pt: O bloco literal não é considerado como um todo. Cada linha será traduzida separadamente.

note: type: textblock
en: Locale::Po4a::Ini - convert INI files from/to PO files
pt: Locale::Po4a::Ini - converter ficheiros INI de/para ficheiros PO

note: type: textblock
en: Locale::Po4a::Ini is a module to help the translation of INI files into other [human] languages.
pt: Locale::Po4a::Ini é um módulo para ajudar a tradução de ficheiros INI noutras línguas [humanas].

note: type: textblock
en: The module searches for lines of the following format and extracts the quoted text:
pt: O módulo procura linhas com o seguinte formato e extrai o texto citado:

note: type: textblock
en: identificator="text than can be translated"
pt: identificator="texto que pode ser traduzido"

note: type: textblock
en: NOTE: If the text is not quoted, it will be ignored.
pt: NOTA: Se o texto não é citado, será ignorado.

note: type: textblock
en: Locale::Po4a::KernelHelp - convert kernel configuration help from/to PO files
pt: Locale::Po4a::KernelHelp - converte a ajuda de configuração do kernel de/para ficheiros 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.
pt: Locale::Po4a::KernelHelp é um módulo para ajudar a tradução de documentação para as opções de configuração do kernel Linux para outras línguas [humanas].

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.
pt: Este módulo foi escrito há pouco tempo e precisa de mais testes. A maior parte do trabalho necessário abrangerá as ferramentas utilizadas para analisar este ficheiro (e configurar o kernel), para que elas aceitem ler a documentação de outro ficheiro (traduzido).

note: type: textblock
en: Locale::Po4a::LaTeX - convert LaTeX documents and derivates from/to PO files
pt: Locale::Po4a::LaTeX - converte documentos LaTeX e derivados de/para ficheiros 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.
pt: Locale::Po4a::LaTeX é um módulo para ajudar a tradução de documentos LaTeX em outras línguas [humanas]. Também pode ser usado como uma base para a construção de módulos para documentos de base LaTeX.

note: type: textblock
en: This module contains the definitions of common LaTeX commands and environments.
pt: Este módulo contém as definições comuns dos comandos e ambientes do LaTeX .

note: type: textblock
en: See the L<Locale::Po4a::TeX(3pm)|Locale::Po4a::TeX> manpage for the list of recognized options.
pt: Veja o manual L<Locale::Po4a::TeX(3pm)|Locale::Po4a::TeX> para a lista de opções reconhecidas.

note: type: textblock
en: Locale::Po4a::Man - convert manual pages from/to PO files
pt: Locale::Po4a::Man - converte páginas do manual de/para ficheiros 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.
pt: Locale::Po4a::Man é um módulo para ajudar na tradução de documentação em formato nroff (a linguagem das páginas do manual) em outras línguas [humanas].

note: type: =head1
en: TRANSLATING WITH PO4A::MAN
pt: TRADUZINDO COM 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.
pt: Este módulo tenta com muita força facilitar a vida do tradutor. Para isso, o texto apresentado aos tradutores não é uma cópia literal do texto encontrado na página do manual. De facto, as partes mais cruas do formato nroff estão escondidos, por isso os tradutores não se podem atrapalhar com elas.

note: type: =head2
en: Text wrapping
pt: Envolver Texto

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.
pt: Parágrafos não recuados são automaticamente re-envolvidos para o tradutor. Isto pode levar a uma diferença menor nos resultados gerados, uma vez que as regras de re-envolvimento usadas por groff não são muito claras. Por exemplo, dois espaços depois de um parêntese às vezes são preservados.

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.
pt: De qualquer forma, a diferença será apenas sobre a posição dos espaços extra no parágrafo envolvido, e acho que vale a pena.

note: type: =head2
en: Font specification
pt: Especificação da 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:
pt: A primeira mudança é sobre as especificações de mudança de font.   No nroff, existem várias maneiras para especificar se uma determinada palavra deve ser escrita em pequeno, negrito ou itálico. No texto para traduzir, só há um caminho, emprestado do formato POD (Perl documentação on-line):

note: type: =item
en: IE<lt>textE<gt> -- italic text
pt: IE<lt>textE<gt> -- texto em itálico

note: type: textblock
en: equivalent to \fItext\fP or ".I text"
pt: equivalente a \fItext\fP or ".I text"

note: type: =item
en: BE<lt>textE<gt> -- bold text
pt: BE<lt>textE<gt> -- texto em negrito

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

note: type: =item
en: RE<lt>textE<gt> -- roman text
pt: RE<lt>textE<gt> -- texto romano

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

note: type: =item
en: CWE<lt>textE<gt> -- constant width text
pt: CWE<lt>textE<gt> -- texto de largura constante

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

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.
pt: Observação: O rosto CW não está disponível para todos os aparelhos groff. Não é recomendado usá-lo. Ele é fornecido para sua conveniência.

note: type: =head2
en: Automatic characters transliteration
pt: Transliteração automática de caracteres

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:
pt: Po4a automaticamente translitera alguns caracteres para facilitar a tradução ou revisão da tradução. Aqui está a lista das transliterações:

note: type: =item
en: hyphens
pt: hífenes

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.
pt: Hífens (-) e sinais de menos (\-) em páginas de manual são todos transliterados como traços simples (-) no ficheiro PO. Assim todos os traços são transliterados em sinais roff menos (\-) quando a tradução é inserida no documento resultante.

note: type: textblock
en: Translators can force an hyphen by using the roff glyph '\[hy]' in their translations.
pt: Os tradutores podem forçar um hífen a usar o roff glyph '\[hy]' nas suas traduções.

note: type: =item
en: non-breaking spaces
pt: espaços não-separáveis

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 ('\ ').
pt: Os tradutores podem usar espaços não separáveis nas suas traduções. Estes espaços não separáveis (0xA0 em latin1) serão transliterados num roff non-breaking space ('\ ').

note: type: =item
en: quotes transliterations
pt: transliterações citadas

note: type: textblock
en: `` and '' are respectively tranliterated into \*(lq and \*(rq.
pt: `` e '' são respetivamente, transliterados em \*(lq and \*(rq.

note: type: textblock
en: To avoid these transliterations, translators can insert a zero width roff character (i.e., using `\&` or '\&' respectively).
pt: Para evitar essas transliterações, os tradutores podem inserir um caractere roff de largura zero (ou seja, a usar `\ &` or '\&' respectivamente).

note: type: =head2
en: Putting 'E<lt>' and 'E<gt>' in translations
pt: Colocando 'E<lt>' e 'E<gt>' em traduções

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).
pt: Desde que estes carácteres são utilizadas para delimitar partes sob modificação da font, não os pode usar na íntegra. Use EE<lt>ltE<gt> e EE<lt>gtE<gt> em vez (como em POD, mais uma vez).

note: type: textblock
en: Activate debugging for some internal mechanisms of this module.  Use the source to see which parts can be debugged.
pt: Ativar a depuração para alguns mecanismos internos deste módulo. Use a fonte para ver que partes podem ser depuradas.

note: type: textblock
en: Increase verbosity.
pt: Aumentar o detalhe.

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:
pt: Esta opção controla o comportamento do módulo quando ele encontrar uma secção .de, .ie ou .if . Ele pode levar os valores a seguir:

note: type: textblock
en: This is the default value.  The module will fail when a .de, .ie or .if section is encountered.
pt: Este é o valor predefinido. O módulo irá falhar quando uma secção .de, .ie ou .if é encontrada.

note: type: textblock
en: Indicates that the .de, .ie or .if sections must be copied as is from the original to the translated document.
pt: Indica que as secções .de, .ie ou .if, devem ser copiadas como estão no original para o documento traduzido.

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.
pt: Indica que as secções .de, .ie ou .if serão propostas para a tradução. Só deve usar essa opção se uma cadeia traduzível está contida numa destas secções. Caso contrário, I<verbatim> deve ser preferida.

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.
pt: Esta opção especifica que o ficheiro foi gerado e que po4a não deve tentar detetar se as páginas man foram geradas de outro formato. Esta opção é obrigatória para usar po4a em páginas man geradas. Note que traduzir páginas geradas em vez das páginas fonte é geralmente mais frágil, e assim uma má ideia.

note: type: textblock
en: This option is only useful for mdoc pages.
pt: Esta opção só é útil para páginas 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.
pt: Seleciona um rigoroso suporte do formato mdoc ao dizer ao po4a para não traduzir a secção 'NOME'. Páginas mdoc cuja secção 'NOME' é traduzida não irá gerar qualquer cabeçalho ou rodapé.

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
pt: De acordo com a página groff_mdoc, as secções NOME, RESUMO e DESCRIÇÃO
    são obrigatórias.
    Não existem problemas conhecidos com a secções RESUMO ou DESCRIÇÃO traduzidas,
    mas também pode especificar estas secções da seguinte forma:
     -o mdoc=NAME,SYNOPSIS,DESCRIPTION

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"
pt: Este problema do mdoc também pode ser resolvido com uma adenda como esta:
     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:
pt: As opções a seguir especificam o comportamento de uma macro definida pelo utilizador (com uma requisição .de) ou de uma macro clássica que não encontra suporte no po4a. Elas levam como argumento uma lista separada por vírgulas de macros.    Por exemplo:

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.
pt: Nota: se uma macro não é suportada pelo po4a e se considerar que é uma macro roff standard, deve submetê-la à equipa de desenvolvimento do po4a.

note: type: textblock
en: B<untranslated> indicates that this macro (at its arguments) don't have to be translated.
pt: B<untranslated> indica que esta macro (nos seus argumentos) não tem que ser traduzida.

note: type: textblock
en: B<noarg> is like B<untranslated>, except that po4a will verify that no argument is added to this macro.
pt: B<noarg> é como B<untranslated>, exceto que po4a irá verificar que nenhum argumento é adicionado a esta macro.

note: type: textblock
en: B<translate_joined> indicates that po4a must propose to translate the arguments of the macro.
pt: B<translate_joined> indica que po4a deve propor a tradução dos argumentos da 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.
pt: Com B<translate_each>, os argumentos também serão propostos para a tradução, excepto que cada um será traduzido em separado.

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.
pt: Essa opção usa como argumento uma lista de pares separados por vírgulas I<begin>:I<End>, onde I<begin> e I<End> são comandos que delimitam o começar e terminar de uma secção que não deve ser re-envolvida.

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.
pt: Nota: nenhum teste é feito para assegurar que um comando I<end> corresponde ao seu comando I<begin>; qualquer comando de finalização termina o modo no_wrap. Se tem uma macro I<begin> (respectivamente I<end>) que não possui I<end> (respectivamente I<begin>), Pode especificar uma I<end> existente (como fi) ou I<begin> (como nf) como uma contraparte. Essas macros (e os argumentos deles) não serão traduzidos.

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.
pt: Esta opção especifica uma lista de macros separadas por vírgulas que não devem dividir o parágrafo atual. A cadeia a traduzir conterá então I<foo E<lt>.bar baz quxE<gt> quux> onde I<bar> é o comando que deve ser embutido, e I<baz qux> os seus argumentos.

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).
pt: Esta opção indica como po4a deve se comportar quando uma macro desconhecida é encontrada. Por predefinição, po4a falha com um aviso.   Ele pode tomar os seguintes valores: B<failed> (o valor predefinido), B<untranslated>, B<noarg>, B<translate_joined>, ou B<translate_each> (ver acima para uma explicação destes valores).

note: type: =head1
en: AUTHORING MAN PAGES COMPLIANT WITH PO4A::MAN
pt: AUTORIA DAS PÁGINAS DE MANUAL COMPATÍVEL COM 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.
pt: Este módulo é ainda muito limitado e, sempre vai ser, porque não é um intérprete nroff real. Seria possível fazer um intérprete nroff real, permitir que os autores usarem todas as macros existentes, ou até mesmo para definir novas nas suas páginas, mas não quisemos. Seria muito difícil e pensamos que não era necessário. Pensamos que se os autores das páginas de manual quiserem ver as suas produções traduzidas, devem ter de se adaptar a facilitar o trabalho dos tradutores.

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.
pt: Portanto, o analisador de manual implementado em po4a tem algumas limitações conhecidas que são e não estamos realmente inclinados a corrigir e que constituirá algumas armadilhas que tem de evitar se quiser ver tradutores cuidarem da sua documentação.

note: type: =head2
en: Don't program in nroff
pt: Não programe em 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).
pt: nroff é uma linguagem de programação completa, com a definição de macro, condicionais e assim por diante. Uma vez que este analisador está totalmente caracterizado como intérprete nroff, irá falhar em páginas que utilizam estas facilidades (há cerca de 200 tais páginas na minha caixa).

note: type: =head2
en: Use the plain macro set
pt: Use o conjunto de macro simples

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.
pt: Existem ainda algumas macros que não são suportadas por po4a::man. É assim porque eu não encontrei nenhuma documentação sobre elas. Aqui está a lista de macros sem suporte, utilizadas na minha caixa. Note que esta lista não é exaustiva uma vez que o programa falha na primeira macro, que encontra sem suporte. Se tem alguma informação sobre algumas desses macros, ficarei feliz em adicionar suporte para elas. Devido a estas macros, cerca de 250 páginas na minha caixa são inacessíveis para po4a::man.

note: type: =head2
en: Hiding text from po4a
pt: Escondendo texto de 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.
pt: Às vezes, o autor sabe que algumas partes não são traduzíveis e não devem ser extraídas por po4a. Por exemplo, uma opção pode aceitar um argumento I<other> e I<other> também pode aparecer como o último item duma lista. No primeiro caso, I<other> não deve ser traduzido. E, no segundo caso, I<other> deve ser traduzido.

note: type: textblock
en: In such case, the author can avoid po4a to extract some strings, using some special groff constructs:
pt: Em tal caso, o autor pode evitar po4a para extrair algumas cadeias, a usar algumas construções especiais groff:

note: type: textblock
en: (this will require the B<-o groff_code=verbatim> option)
pt: (isto vai exigir a opção B<-o groff_code=verbatim>)

note: type: verbatim
en: A new macro can also be defined to automate this:
     .de IR_untranslated
     .    IR \\$@
     ..
pt: A nova macro também pode ser definida para automatizar isto:
     .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)
pt: (isto vai exigir as opções B<-o groff_code=verbatim> e B<-o untranslated=IR_untranslated>; com esta construção, o B<.if !'po4a'hide'> condicional não é estritamente necessário uma vez que po4a não irá analisar o interno da definição da macro)

note: type: verbatim
en: or using an alias:
     .als IR_untranslated IR
pt: ou utilizar um alias: 
     .als IR_untranslated IR

note: type: textblock
en: This will require the B<-o untranslated=als,IR_untranslated> option.
pt: Isso vai exigir a opção B<-o untranslated=als,IR_untranslated>.

note: type: =head2
en: Conclusion
pt: Conclusão

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.
pt: Para resumir esta secção, mantenha simples e não tente ser inteligente a quanto da autoria das suas páginas de manual. Muitas coisas são possíveis em nroff e não suportadas por este analisador. Por exemplo, não tente mexer em \c para interromper o processamento de texto (como 40 páginas na minha caixa fazem). Ou seja, certifique-se de pôr os argumentos da macro na mesma linha em que a macro está. Sei que é válido em nroff, mas iria complicar muito o analisador para ser tratado.

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.
pt: É claro, outra possibilidade é usar outro formato, mais amigável ao tradutor (como POD a usar po4a::pod ou um da família XML como o SGML), mas graças ao po4a::man isso não é mais necessário. Tendo dito isso, se o formato fonte da documentação é POD, ou XML, pode ser inteligente traduzir o formato fonte e não este gerado. Na maioria dos casos, po4a::man vai detetar páginas geradas e mostrar um aviso. Ele vai até mesmo recusar processar páginas geradas no POD porque tais páginas são lidadas perfeitamente pelo po4a::pod, e porque sua contraparte nroff define um monte de novas macros que eu não desejo dar suporte. Na minha máquina, 1432 das 4323 páginas são geradas de POD e vão ser ignoradas pelo 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…
pt: Geralmente, po4a::man vai detetar o problema e se recusar a processar a página, e apresentar uma mensagem adaptada. Em alguns casos raros, o programa vai completar sem avisos, mas o resultado estará errado. Tais casos são chamados de "bugs" ;) Se encontrar tal caso, certifique-se de reporta-lo, com uma solução, quando possível…

note: type: textblock
en: This module can be used for most of the existing man pages.
pt: Este módulo pode ser usado para a maioria das páginas de manual existentes.

note: type: textblock
en: Some tests are regularly run on Linux boxes:
pt: Alguns testes são regularmente executados em máquinas Linux:

note: type: =item
en: one third of the pages are refused because they were generated from another format supported by po4a (e.g. POD or SGML).
pt: um terço das páginas são recusadas porque foram geradas a partir de outro formato suportado pelo po4a (por exemplo, POD ou SGML).

note: type: =item
en: 10% of the remaining pages are rejected with an error (e.g. a groff macro is not supported).
pt: 10% das páginas remanescentes são rejeitadas com um erro (por exemplo, uma macro groff não é suportada).

note: type: =item
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)
pt: Então, menos de 1% das páginas são aceites por po4a em silencio, mas com problemas significativos (ou seja, palavras que faltam, ou palavras novas inseridas)

note: type: =item
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).
pt: As outras páginas são geralmente tratadas sem diferenças mais importantes do que as diferenças de espaçamento ou linhas re-envolvidas (problemas com fontes são menos de 10% das páginas processadas).

note: type: textblock
en: Locale::Po4a::Org - convert Org documents from/to PO files.
pt: Locale::Po4a::Org - converte documentos Org de/para ficheiros PO.

note: type: textblock
en: C<Locale::Po4a::Org> is a module to help the translation of documentation in the Org format, used by the L<Org Mode|https://orgmode.org/>.
pt: C<Locale::Po4a::Org> é um módulo para ajudar a tradução de documentação no formato Org, usado pelo L<Org Mode|https://orgmode.org/>.

note: type: =head1
en: CONFIGURATION
pt: CONFIGURAÇÃO

note: type: textblock
en: Space-separated list of keywords which won't be translated.
pt: Lista separada por espaços de palavras-chave que não serão traduzidas.

note: type: textblock
en: Space-separated list of properties which won't be translated.
pt: Lista separada por espaços de propriedades que não serão traduzidas.

note: type: textblock
en: If this is a true value, skip translating headings.  When your translation is converted to Texinfo format, the translation of headings can cause node names to become bizarre.  This option prevents that.
pt: Se este for um valor true, pula a tradução de títulos.   Quando a sua tradução é convertida para o formato Texinfo, a tradução de títulos pode fazer com que nomes dos nós se tornem bizarros.   Esta opção previne isto.

note: type: textblock
en: This module is in an early stage of development.  It is tested successfully on simple Org files, such as the L<Org Mode Compact Guide|https://orgmode.org/guide/>.  However it does not support the full L<Org syntax|https://orgmode.org/worg/org-syntax.html>; footnotes and nested plain lists cannot currently be parsed, for example.
pt: Este módulo está num estágio inicial de desenvolvimento. Ele foi testado com sucesso em ficheiros Org simples, como o L<Org Mode Compact Guide|https://orgmode.org/guide/>. No entanto, ele não suporta a sintaxe L<Org syntax|https://orgmode.org/worg/org-syntax.html> completa; notas de rodapé e listas simples aninhadas não podem ser analisadas atualmente, por exemplo.

note: type: textblock
en: This program is free software; you may redistribute it and/or modify it under the terms of GPL v2.0 or later (see the F<COPYING> file).
pt: Este programa é software livre; pode redistribuí-lo e/ou modificá-lo sob os termos da GPL v2.0 ou posterior (veja o ficheiro F<COPYING>).

note: type: textblock
en: Locale::Po4a::Po - PO file manipulation module
pt: Locale::Po4a::Po - módulo de manipulação dum ficheiro 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.
pt: Locale::po4a:: Po é um módulo que permite que manipule catálogos de mensagens. Pode carregar e escrever de/para um ficheiro (cuja extensão é muitas vezes I<po>), pode construir novas entradas na execução ou pedir uma tradução de uma cadeia.

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"').
pt: Para uma descrição mais completa do catálogo de mensagens no formato PO e o uso dele, por favor veja a documentação info do programa gettext. (nó "`Ficheiros PO"').

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.
pt: Este módulo é parte do projeto po4a, cujo objetivo é usar ficheiros PO (projetado na origem para facilitar a tradução de mensagens do programa) para traduzir tudo, inclusive a documentação (página do manual, manual de informação), descrição do pacote, modelos debconf e tudo o que pode beneficiar a partir deste.

note: type: =head1
en: Functions concerning entire message catalogs
pt: Funções relativas a catálogos de mensagens inteiros

note: type: =item
en: new()
pt: novo()

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.
pt: Cria um catálogo de mensagem novo. Se um argumento é fornecido, é o nome dum ficheiro PO que deve carregar.

note: type: =item
en: read($)
pt: ler($)

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.
pt: Lê um ficheiro PO (que o nome é dado como argumento). Entradas previamente existentes em si não são removidas, os novos são adicionados ao fim do catálogo.

note: type: =item
en: write($)
pt: escrever($)

note: type: textblock
en: Writes the current catalog to the given file.
pt: Escreve o catálogo atual no ficheiro dado.

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).
pt: Como escrever, mas se o ficheiro PO ou POT já existe, o objeto será escrito num ficheiro temporário, que será comparado com o ficheiro existente para verificar se a atualização é necessária (isso evita mudar um POT apenas para atualizar uma linha de referência ou o campo POT-Creation-Date).

note: type: =item
en: filter($)
pt: filtro($)

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.
pt: Esta função extrai um catálogo a partir de um já existente. Somente as entradas que têm uma referência no ficheiro dado serão postas no catálogo resultante.

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.
pt: Esta função analisa o seu argumento, converte-o para uma definição função Perl, avalia esta definição e filtra os campos para os quais esta função retornará verdadeiro.

note: type: textblock
en: I love Perl sometimes ;)
pt: Algumas vezes gosto de Perl ;)

note: type: =head1
en: Functions to use a message catalog for translations
pt: Funções para utilizar um catálogo de mensagens para traduções

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.
pt: Pede a tradução duma dada sequência como argumento no catálogo atual. Esta função retorna a sequência (não traduzida) original, se a cadeia não foi encontrada.

note: type: textblock
en: After the string to translate, you can pass a hash of extra arguments. Here are the valid entries:
pt: Após a cadeia para traduzir, pode passar um 'hash' de argumentos adicionais. Aqui são as entradas válidas:

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.
pt: um booleano que indica se podemos considerar que os espaços em branco na cadeia não são importantes. Se sim, a função canoniza a cadeia antes de procurar uma tradução e envolve o resultado.

note: type: textblock
en: the column at which we should wrap (default: 76).
pt: a coluna em que devemos envolver (predefinição: 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:
pt: Retorna estatísticas sobre a taxa de acerto de gettext desde a última vez que stats_clear() foi chamado. Por favor, note que não são as mesmas estatísticas que são impressas por msgfmt --statistic. Aqui, são as estatísticas sobre o recente uso do ficheiro PO, enquanto msgfmt informa sobre o estado do ficheiro. Exemplo de uso:

note: type: verbatim
en:     [some use of the PO file to translate stuff]
    
        ($percent,$hit,$queries) = $pofile->stats_get();
        print "So far, we found translations for $percent\%  ($hit of $queries) of strings.\n";
pt:     [algum uso do ficheiro PO para traduzir coisas]
    
        ($percent,$hit,$queries) = $pofile->stats_get();
        print "Até agora, encontramos traduções para $percent\% ($hit de $queries) de cadeias.\n";

note: type: textblock
en: Clears the statistics about gettext hits.
pt: Limpa as estatísticas sobre os êxitos do gettext.

note: type: =head1
en: Functions to build a message catalog
pt: Funções para a construção de um catálogo de mensagens

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:
pt: Força uma nova entrada no final do catálogo atual. Os argumentos devem formar uma tabela hash. As chaves válidas são:

note: type: textblock
en: the string in original language.
pt: a cadeia no idioma original.

note: type: textblock
en: the translation.
pt: a tradução.

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.
pt: uma indicação de onde essa cadeia foi encontrada. Exemplo: file.c:46 (ou seja, em 'file.c' na linha 46). Pode ser uma lista separada por espaços em caso de múltiplas ocorrências.

note: type: textblock
en: a comment added here manually (by the translators). The format here is free.
pt: um comentário adicionado aqui manualmente (pelo tradutor). O formato é livre.

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.
pt: um comentário que foi adicionado automaticamente pelo programa de extração da cadeia. Veja a opção B<--add-comments> do programa B<xgettext> para obter mais informações.

note: type: textblock
en: space-separated list of all defined flags for this entry.
pt: lista separada por espaços de todas as bandeiras definidas para esta entrada.

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>.
pt: As bandeiras válidas são: 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>.

note: type: textblock
en: See the gettext documentation for their meaning.
pt: Consulte a documentação do gettext para o significado delas.

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.
pt: este é mais um argumento interno: é usado enquanto os documentos são 'gettextizados'. A ideia aqui é analisar tanto o original como a tradução num objeto PO e fundi-los, a usar um 'msgid' como 'msgid' e os outros 'msgid' como 'msgstr'. Para ter certeza de que as coisas ficam bem, cada 'msgid em objetos PO recebem um tipo, com base na estrutura deles (como "chapt", "sect1", "p" e assim por diante em DocBook). Se os tipos de cadeias não são as mesmas, significa que ambos os ficheiros não partilham a mesma estrutura e, o processo e informa um erro.

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.
pt: Esta informação é escrita como comentário automático no ficheiro PO uma vez que dá aos tradutores algum contexto sobre as cadeias para traduzir.

note: type: textblock
en: boolean indicating whether whitespaces can be mangled in cosmetic reformattings. If true, the string is canonized before use.
pt: booleano que indica se os espaços em branco podem ser mutilados em cosméticas reformatações. Se for verdade, a cadeia está canonizada antes do uso.

note: type: textblock
en: This information is written to the PO file using the B<wrap> or B<no-wrap> flag.
pt: Esta informação é gravada no ficheiro PO que usa a bandeira B<wrap> ou B <no-wrap>.

note: type: textblock
en: ignored; the key is kept for backward computability.
pt: ignorada; a chave é mantida para computabilidade retroativa.

note: type: =head1
en: Miscellaneous functions
pt: Funções variadas

note: type: textblock
en: Returns the number of entries in the catalog (without the header).
pt: Retorna a quantidade de entradas no catálogo (sem o cabeçalho).

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.
pt: Retorna a quantidade de entradas no documento. Se uma cadeia aparece múltiplas vezes no documento, será contada múltiplas vezes.

note: type: textblock
en: Returns the msgid of the given number.
pt: Retorna o identificador de mensagem do número dado.

note: type: textblock
en: Returns the msgid with the given position in the document.
pt: Retorna o identificador de mensagem na posição dado do 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.
pt: Retorna o tipo de msgid com a posição dada no documento. Provavelmente, isso só é útil para gettextização e é armazenado separadamente de {$msgid}{'type'} porque o local posterior pode ser substituído por outro tipo quando $msgid é duplicado no documento mestre.

note: type: textblock
en: Returns the character set specified in the PO header. If it hasn't been set, it will return "UTF-8".
pt: Retorna o conjunto de caracteres especificado no cabeçalho PO. Se não foi definido, irá retornar "UTF-8".

note: type: textblock
en: Locale::Po4a::Pod - convert POD data from/to PO files
pt: Locale::Po4a::Pod - converte dados POD de/para ficheiros PO

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.
pt: Locale::Po4a:: Pod é um módulo para ajudar a tradução da documentação em formato POD (o idioma preferido para documentar Perl) em outras línguas [humanas].

note: type: textblock
en: A new L<SimplePod|Locale::Po4a::SimplePod> parser is now available.  Please consider using it instead of the current Pod module.  If you encounter any bugs, your reports would be greatly appreciated.
pt: Um novo analisador L<SimplePod|Locale::Po4a::SimplePod> está agora disponível.  Por favor considere usa-lo em vez do módulo Pod atual.  Se encontrar quaisquer bugs, os seus relatórios serão muito apreciados.

note: type: textblock
en: The above warning message will be displayed for a transitional period.  To disable it, set the C<no-warn-simple> option.
pt: A mensagem de aviso em cima será mostrada por um período de transição.  Para a desativar, defina a opção C<no-warn-simple>.

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:
pt: Acho que este módulo é estável que nem rocha, e há apenas um erro conhecido com F</usr/lib/perl5/Tk/MainWindow.pod> (e algumas outras páginas, veja abaixo) que contém:

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:
pt: Por falta de sorte, na versão do po4a, isto foi divido no espaço pelo dimensionamento. Como resultado, na versão original, a página man contém:

note: type: textblock
en: and mine contains:
pt: e o meu contém:

note: type: textblock
en: which is logic since CE<lt>foobarE<gt> is rewritten "foobar".
pt: O que é lógico desde que CE<lt>foobarE<gt> está a rescrever "foobar".

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):
pt: Lista completa de páginas com este problema na minha caixa (de 564 páginas; observe que depende da coluna escolhida para quebra de texto):

note: type: =head1
en: INTERNALS
pt: INTERNAS

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().
pt: Como uma classe derivada de Pod::Parser, Locale::Po4a::Pod suporta o mesmo métodos e interfaces. Ver L<Pod::Parser> para todos os detalhes, com brevidade, cria um novo analisador com C<< Locale::Po4a::Pod->new() >> e depois invoca também parse_from_filehandle() ou parse_from_file().

note: type: textblock
en: Locale::Po4a::RubyDoc -- Convert Ruby Document data from/to PO files
pt: Locale::Po4a::RubyDoc - Converte dados de Ruby Document de/para ficheiros 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.
pt: Locale::Po4a::RubyDoc é um módulo para ajudar a tradução de documentação no formato Ruby Document (Rad) (a linguagem usada para documentar Ruby) para outros idiomas [humanos].

note: type: textblock
en: This module has been successfully tested on simple Ruby Document files covering a good part of the format syntax.
pt: Este módulo foi testado com sucesso em ficheiros de Ruby Document simples cobrindo uma boa parte da sintaxe do 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...
pt: Uma limitação conhecida é que ele falha em reconhecer adequadamente a estrutura empilhada do Documento Ruby de entrada: isso implica que quando, por exemplo, um EnumListItem consiste em mais de um Bloco, apenas o primeiro Bloco é realmente reconhecido como EnumListItem, enquanto os subsequentes são considerados apenas como TextBlocks...

note: type: textblock
en: This module supports the following option:
pt: Este módulo suporta a seguinte opção:

note: type: textblock
en: Handle files entirely made of Ruby Document formatted text (without any "=begin" line).
pt: Manipula ficheiros inteiramente feitos de texto formatado de Ruby Document (sem nenhuma linha "=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).
pt: Por predefinição, este módulo manipula apenas texto formatado de Ruby Document entre as linhas "=begin" e "=end" (assim ignorando, entre outras coisas, tudo o que precede a primeira linha "=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.
pt: Esta obra é software livre; pode redistribuí-la e/ou modificá-la sob os termos da Licença Pública Geral GNU conforme publicada pela Free Software Foundation; tanto a versão 2 da Licença, ou (por sua opção) qualquer versão posterior.

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.
pt: Esta obra é distribuída na esperança de ser útil, mas SEM NENHUMA GARANTIA; sem mesmo a garantia implícita de COMERCIALIZAÇÃO ou ADEQUAÇÃO A UM DETERMINADO FIM. Veja a Licença Pública Geral GNU para mais detalhes.

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.
pt: Deve ter recebido uma cópia da Licença Pública Geral GNU junto com este trabalho; se não, escreva para 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:
pt: Partes do código (como muitas expressões regulares) foram adaptadas do código-fonte do rdtool, sob os termos da Licença Pública Geral GNU, versão 2 ou posterior. Essas partes são originalmente:

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:
pt: O código de inicialização foi adaptado do código-fonte de Locale::Po4a::Text, nos termos da Licença Pública Geral GNU, versão 2 ou posterior. Este código era originalmente:

note: type: textblock
en: Locale::Po4a::Sgml - convert SGML documents from/to PO files
pt: Locale::Po4a::Sgml - converte documentos SGML de/para ficheiros 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.
pt: Locale::Po4a::Sgml é um módulo para ajudar a tradução da documentação no formato SGML em outros idiomas [humanos].

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.
pt: Este módulo usa B<onsgmls>(1) para analisar os ficheiros SGML. Certifique-se de que é instalado. Certifique-se também de que o DTD dos ficheiros SGML está instalado no sistema.

note: type: textblock
en: Space-separated list of keywords indicating which category of extra debug messages should be shown. Possible values are: C<entities>, C<generic>, C<onsgml>, C<refs> and C<tag>.
pt: Lista de palavras-chave separadas por espaços que indicam qual categoria de mensagens de depuração extras deve ser mostrada. Os valores possíveis são: C<entities>, C<generic>, C<onsgml>, C<refs> e C<tag>.

note: type: textblock
en: Give more information about what's going on.
pt: Dá mais informações sobre o que está a acontecer.

note: type: textblock
en: Space-separated list of extra tags (beside the DTD provided ones) whose content should form an extra msgid, i.e that should be translated.
pt: Lista separada por espaços das marcações extras (além daquelas fornecidas por DTD) cujo conteúdo deveria formar um msgid extra, isto é, deveria ser traduzido.

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>.
pt: Lista separada por espaços das marcações extras (além daquelas fornecidas por DTD) contendo outras marcações, algumas delas sendo da categoria B<translate>.

note: type: textblock
en: Space-separated list of tags which increase the indentation level. This will affect the indentation in the resulting document.
pt: Lista separada por espaços de marcações que aumentam o nível de indentação. Isso afetará a indentação no documento resultante.

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.
pt: A apresentação dentro dessas marcas não deve ser alterada. Este parágrafo não vai ficar envolvido e não há espaço de recuo adicional ou nova linha será adicionada para finalidade estética.

note: type: textblock
en: Tags not needing to be closed.
pt: Etiquetas que não precisam ser fechadas.

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 B<translate> section would create a msgids with only its content, (and it's usually not a whole sentence), which is bad.
pt: Etiquetas ignoradas e consideradas como simples dados de caracteres pelo po4a. Isso quer dizer que elas podem ser parte de um identificador de mensagem. Por exemplo, E<lt>bE<gt> é um bom candidato para esta categoria pois pô-lo na secção B<translate> criaria identificadores de mensagens com apenas o seu conteúdo, (e geralmente não são frases inteiras), o que é mau.

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, C<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: C<< <bbb><aaa>lang >> specifies that the lang attribute will only be translated if it is in an C<< <aaa> >> tag, which is in a C<< <bbb> >> tag.  The tag names are actually regular expressions so you can also write things like C<< <aaa|bbb>lang >> to only translate C<lang> attributes that are in an C<< <aaa> >> or a C<< <bbb> >> tag.
pt: Uma lista separada por espaços de atributos que precisam ser traduzidos. Pode especificar os atributos pelos seus nomes (por exemplo, C<lang>), mas também pode prefixá-la com uma hierarquia de etiquetas, para especificar que este atributo só será traduzido quando estiver na etiqueta especificada. Por exemplo: C<< <bbb><aaa>lang >> especifica que o atributo lang só será traduzido se ele estiver numa etiqueta C<< <aaa> >>, que está numa etiqueta C<< <bbb> >>. Os nomes de etiquetas são, na verdade, expressões regulares, de forma que também pode escrever coisas como C<< <aaa|bbb>lang >> para traduzir apenas atributos C<lang> que estão numa etiqueta C<< <aaa> >> ou uma etiqueta C<< <bbb> >>.

note: type: textblock
en: A space-separated list of attributes for which the translation must be qualified by the attribute name, i.e. the text extracted for the translation will include both the attributes name and it's value. e.g. for a tag like C<< <aaa lang_en="foo"> >> translators will be presented with the string C<lang_en="foo">. Note that this also automatically adds the given attribute into the B<attributes> list too.
pt: Uma lista separada por espaços de atributos para os quais a tradução deve ser qualificada pelo nome do atributo, isto é, o texto extraído para a tradução incluirá o nome e o valor do atributo. Por exemplo, para uma etiqueta como C<< <aaa lang_en="foo"> >> os tradutores receberão a cadeia C<lang_en="foo">. Observe que isto também adiciona automaticamente o atributo fornecido à lista B<attributes>.

note: type: textblock
en: Proceed even if the DTD is unknown or if B<onsgmls> finds errors in the input file.
pt: Continua mesmo na eventualidade do DTD ser desconhecido ou se B<onsgmls> encontrar erros no ficheiro de entrada.

note: type: textblock
en: By default, msgids containing only one entity (like C<&version;>) are skipped for the translators' comfort. Activating this option prevents this optimisation. It can be useful if the document contains a construction like C<< <title>&Aacute;</title> >>, even if I doubt such things to ever happen...
pt: Por predefinição, msgids que contenham apenas uma entidade (como C<&version;>) são ignorados para o conforto dos tradutores. Ao ativar esta opção previne-se esta otimização. Ela pode ser útil se a documentação conter uma construção como C<< <title>&Aacute;</title> >>, mesmo duvidando que este tipo de coisa venha a acontecer...

note: type: textblock
en: Space-separated list of entities that won't be inlined.  Use this option with caution: it may cause B<onsgmls> (used internally) to add tags and render the output document invalid.
pt: Lista separada por espaços de entidades que não serão embutidas. Use esta opção com cuidado: ela pode levar o B<onsgmls> (usado internamente) a adicionar etiquetas e invalidar o documento resultante.

note: type: textblock
en: The result is perfect. I.e., the generated documents are exactly the same as the originals. But there are still some problems:
pt: O resultado é perfeito. Isto é, os documentos gerados são exatamente os mesmos que os originais. Mas ainda há alguns problemas:

note: type: =item
en: The error output of B<onsgmls> is redirected to /dev/null by default, which is clearly bad. I don't know how to avoid that.
pt: A saída de erro do B<onsgmls> é redirecionada para /dev/null por predefinição, o que obviamente é ruim. Não sei como evitar isso.

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 B<onsgmls>. Otherwise B<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}>.
pt: O problema é que tenho que "proteger" as inclusões condicionais (i.e. as C<E<lt>! [ %foo [> e C<]]E<gt>>) do B<onsgmls>. Caso contrário, B<onsgmls> devora-as e não sei como restaurá-las no documento final. Para evitar isso, reescrevo-as para 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).
pt: O problema com isso é que o C<{PO4A-end}> e outros que acrescento, são inválidos no documento (não numa etiqueta E<lt>pE<gt> ou semelhante).

note: type: textblock
en: If you want to view the B<onsgmls> output, just add the following to your command line (or po4a configuration line):
pt: Se quiser ver a saída do B<onsgmls>, adicione o seguinte à sua linha de comandos (ou linha de configuração po4a):

note: type: =item
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.
pt: Ele funciona apenas com o DebianDoc e DocBook DTD. Adicionar suporte para um novo DTD deve ser muito fácil. O mecanismo é o mesmo para cada DTD, só tem que dar uma lista das etiquetas existentes e algumas das suas características.

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.
pt: Concordo. apenas necessita mais documentação, no entanto pode ser considerado como beta e detesto conteúdos de documentos que podem ainda ser sujeitos a alterações.

note: type: =item
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.
pt: Aviso, o suporte para DTDs é bastante experimental. Não li nenhum manual de referência para encontrar a definição de cada etiqueta. Adicionei a definição de etiqueta para o módulo, até que funciona para alguns documentos que eu encontrei na Internet. Se o documento usar mais etiquetas do que as minhas, não vai funcionar. Mas como eu disse acima, reparar isto deve ser muito fácil.

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.
pt: Testei DocBook contra o SAG (Guia do Administrador do Sistema), mas também este documento é muito grande e deve usar mais especificidades do DocBook.

note: type: textblock
en: For DebianDoc, I tested some of the manuals from the DDP, but not all yet.
pt: Para DebianDoc, testei alguns dos manuais da DDP, mas não todos ainda.

note: type: =item
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.
pt: Em caso de inclusão de ficheiros, a cadeia de referência de mensagens em ficheiros PO (ou seja, linhas como C<#: en/titletoc.sgml:9460>) vai estar errada.

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 C<&version;>) from B<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 B<onsgmls> for parsing.
pt: Isto porque eu pré-processei o ficheiro para proteger a inclusão condicional (i.e. aqueles C<E<lt>! [ %foo [> e C<]]E<gt>>) e algumas entidades (como C<&version;>) do B<onsgmls> porque quero eles verbatim no documento gerado. Para isto, faço uma cópia temporária do ficheiro de entrada e faço todas as alterações que quero nele antes de passá-lo para o B<onsgmls> para análise.

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.
pt: Assim ele funciona, substituí as entidades que pedem a inclusão de ficheiros pelo conteúdo do ficheiro de dados (para que possa proteger também o que precisa de estar num sub-ficheiro também). Mas nada se fez até agora para corrigir as referências (ou seja o nome do ficheiro e o número da linha) mais tarde. Não tenho certeza qual é a melhor coisa a fazer.

note: type: textblock
en: This module is an adapted version of sgmlspl (SGML postprocessor for the ONSGMLS parser) which was:
pt: Este módulo é uma versão adaptada do 'sgmlspl' (pós-processador SGML para os analisadores SGMLS e ONSGMLS) que foi:

note: type: textblock
en: The adaptation for po4a was done by:
pt: A adaptação para po4a foi feita por:

note: type: textblock
en: Locale::Po4a::SimplePod - convert POD data from/to PO files, with Pod::Simple
pt: Locale::Po4a::SimplePod - converte dados POD de/para ficheiros PO, com Pod::Simple

note: type: textblock
en: or
pt: ou

note: type: textblock
en: This is a module to help the translation of documentation in the POD format (the preferred language for documenting Perl) into other human languages.
pt: Isto é um módulo para ajudar a tradução da documentação em formato POD (o idioma preferido para documentar Perl) em outras línguas humanas.

note: type: textblock
en: The main differences between the current Pod format and the SimplePod format are as follows:
pt: As principais diferenças entre o formato Pod atual e o formato SimplePod são as seguintes:

note: type: =item
en: SimplePod format never includes additional newlines in messages to be translated.  The current Pod format, however, may contain extra newlines, particularly in verbatim message entries.
pt: O formato SimplePod nunca inclui novas linhas adicionais nas mensagens a traduzir.  O formato Pod atual, no entanto, pode conter novas linhas extra, em particular em entradas de mensagens literais.

note: type: =item
en: Paragraphs may be rendered with line wrapping.  The L<Pod::Parser> module might apply special handling for line wrapping, making it difficult to replicate with L<Pod::Simple>.  However, L<Pod::Simple> appears to produce a more natural output.
pt: Parágrafos podem ser renderizados com dobragem de linha.  O módulo L<Pod::Parser> pode aplicar manuseamento especial para dobragem de linha, tornando isso difícil de replicar com o L<Pod::Simple>.  No entanto, o L<Pod::Simple> parece produzir resultados mais naturais .

note: type: =item
en: In SimplePod, the C<=for> message (e.g., C<=for comment text>) does not include a format name (such as C<comment>), so the message consists solely of text.  In contrast, the current Pod format retains the format name, resulting in a message like C<comment text>.  The former behavior is considered more comfortable for translators.
pt: No SimplePod, a mensagem C<=for> (ex. C<=for comment text>) não inclui um nome de formato (tal como C<comment>), assim a mensagem consiste apenas de texto.  Em contraste, o formato Pod atual retêm o nome de formato, resultando numa mensagem tipo C<comment text>.  O comportamento anterior é considerado mais confortável para tradutores.

note: type: =item
en: Entries like the one below, which denote C<=end comment>, are no longer present as seen in the current Pod module.  Since these are not translatable messages, their absence is an improvement.
pt: Entradas como a de baixo, que denotam C<=end comment>, já não estão presentes como se via no módulo Pod atual.  Como estas não são mensagens traduzíveis, a sua ausência é uma melhoria.

note: type: =item
en: Text blocks whose POD format validity is uncertain are now treated as C<no-wrap>.  This applies, for example, to the content within a C<=begin html> block.  In the Pod module, these were not treated as C<no-wrap>, which sometimes resulted in line wrapping.
pt: Blocos de texto cuja validade do formato POD é incerta são agora tradados como C<no-wrap>.  Isto aplica-se, por exemplo, ao conteúdo dentro de um bloco C<=begin html>.  No módulo Pod, estes não eram tratados como C<no-wrap>, o que por vezes resultava em dobragem de linha.

note: type: =item
en: The C<=begin> parameter section is no longer subject to translation.  In the current Pod module, it is included.  If there is a demand to include it in translation, please report it.
pt: A secção parâmetro C<=begin> não é mais sujeita a tradução.  No módulo Pod atual, é incluída.  Se existir uma obrigação de a incluir na tradução, por favor reporte isso.

note: type: textblock
en: This module is still newly developed, so it is less stable than L<Locale::Po4a::Pod>.  It continues to evolve, and there is room for further refinement.  Its behavior might change over time, and additional options may be introduced to better optimize the translation experience for users.  Feedback and use cases from real-world applications will play a key role in guiding its future development.
pt: Este módulo é ainda um novo desenvolvimento, assim menos estável que o L<Locale::Po4a::Pod>.  Ele continua a evoluir, e há espaço para mais melhoramentos.  O seu comportamento pode mudar com o tempo, e podem ser introduzidas opções adicionais para melhor optimizar a experiência de tradução para os utilizadores.  O feedback e casos de uso de aplicações do mundo real irão ter um papel chave em guiar o seu futuro desenvolvimento.

note: type: textblock
en: The code is fully covered by our test suite, and we're not aware of any existing bugs.  However, as of 2025, it hasn't been battle-tested in real-world translation workflows by external projects.  That said, we believe the module is ready for production use, even if some bugs may inevitably be discovered as it gains wider adoption.
pt: O código é totalmente coberto pela nossa suite de teste, e não conhecemos nenhuns bugs existentes.  No entanto, até 2025, não foi testado na batalha de fluxos de trabalho de traduções no mundo real por projetos externos.  Dito isto, acreditamentos que o módulo está pronto para uso produtivo, mesmo que alguns bugs sejam inevitavelmente descobertos ao ganhar uma adoção mais ampla.

note: type: textblock
en: This module is intended to replace the current L<Locale::Po4a::Pod> module.  The reason is that L<Pod::Parser>, which is used by the current L<Locale::Po4a::Pod>, is now deprecated, and it is recommended to use L<Pod::Simple> instead.  See also L<GitHub issue #256 "Consider migrating away from deprecated C<Pod::Parser>"|https://github.com/mquinson/po4a/issues/256>.
pt: Este módulo destina-se a substituir o atual módulo L<Locale::Po4a::Pod>.  A razão é que L<Pod::Parser>, o qual é usado pelo actual L<Locale::Po4a::Pod>, está agora descontinuado, e é recomendado usar L<Pod::Simple> em vez deste.  Veja também L<GitHub issue #256 "Consider migrating away from deprecated C<Pod::Parser>"|https://github.com/mquinson/po4a/issues/256>.

note: type: textblock
en: Locale::Po4a::TeX - convert TeX documents and derivatives from/to PO files
pt: Locale::Po4a::TeX - converte documentos TeX e derivados de/para ficheiros 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.
pt: Locale::Po4a::TeX é um módulo para ajudar na tradução de documentos TeX em outras línguas [humanas]. Também pode ser usado como uma base para a construção de módulos para documentos baseados em 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.
pt: Utilizadores provavelmente deveriam usar o módulo LaTeX, o qual herdou do módulo TeX e contém as definições dos comandos comuns do LaTeX.

note: type: =head1
en: TRANSLATING WITH PO4A::TEX
pt: TRADUÇÃO COM 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).
pt: Este módulo pode ser usado diretamente para lidar com documentos genéricos TeX. Isto irá dividir o seu documento em blocos menores (parágrafos, blocos textuais, ou mesmo menores, como títulos ou índices).

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 DERIVATE MODULES> below, for the process description.
pt: Há algumas opções (descritas na próxima secção) que podem personalizar este comportamento.   Se isso não se adequar ao formato do seu documento, encorajamos-o a escrever o seu próprio módulo derivado deste, para descrever os detalhes do seu formato.   Veja a secção abaixo B<WRITING DERIVATE MODULES>, para a descrição do 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.
pt: Esse módulo também pode ser personalizado por linhas iniciais com "% po4a:" no ficheiro TeX. Esse processo é descrito na secção B<INLINE CUSTOMIZATION>.

note: type: textblock
en: Comma-separated list of environments which should not be re-wrapped.
pt: Lista de ambientes separados por vírgulas que não devem ser re-envolvidos.

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.
pt: Note que há uma diferença entre os ambientes verbatim e no_wrap. Não existe um comando e análise de comentários em blocos verbatim (literais).

note: type: textblock
en: If this environment was not already registered, po4a will consider that this environment does not take any parameters.
pt: Se este ambiente não foi já registado, po4a irá considerar que este ambiente não leva nenhum parâmetro.

note: type: textblock
en: Colon-separated list of files that should not be included by \input and \include.
pt: Lista de ficheiros separados por dois pontos que não devem ser incluídos por \input e \include.

note: type: textblock
en: Comma-separated list of environments which should be taken as verbatim.
pt: Lista de ambientes separados por vírgulas que devem ser tomados como literais.

note: type: textblock
en: Use these options to override the default behavior of the defined commands.
pt: Use essas opções para sobrepor o comportamento predefinido dos comandos definidos.

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:
pt: O módulo TeX pode ser personalizado com linhas a começar por B<% po4a:>. Estas as linhas são interpretadas como comandos para o analisador. Os seguintes comandos são reconhecido:

note: type: textblock
en: Indicates that the arguments of the I<command1> command should be treated as the arguments of the I<command2> command.
pt: Indica que os argumentos do comando I<command1> devem ser tratado como os argumentos do comando I<command2>.

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.
pt: Isso descreve em detalhe os parâmetros do comando I<comando1>.   Essa informação será usada para verificar a quantidade de argumentos e os seus tipos.

note: type: textblock
en: You can precede the I<command1> command by
pt: Pode preceder o comando I<command1> por

note: type: =item
en: an asterisk (B<*>)
pt: um 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.
pt: po4a irá extrair este comando a partir de parágrafos (se ele está localizado no começo ou o fim de um parágrafo).  Os tradutores terão então de traduzir os parâmetros que são marcados como traduzível.

note: type: =item
en: a plus (B<+>)
pt: um sinal mais (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).
pt: Assim como o asterisco, o comando será extraído se ele aparecer numa extremidade de um bloco, mas os parâmetros não serão traduzidos separadamente. O tradutor terá que traduzir o comando concatenado a todos os seus parâmetros. Isso mantém mais o contexto e é útil para comandos com palavras pequenas em parâmetro, o qual pode ter múltiplos significados (e traduções).

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.
pt: Nota: Neste caso, não tem que especificar quais os parâmetros que são traduzíveis, mas po4a deve saber o tipo e a quantidade de parâmetros.

note: type: =item
en: a minus (B<->)
pt: um sinal menos (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.
pt: Neste caso, o comando não será extraído a partir de qualquer bloco. Mas se aparece sozinho num bloco, então, apenas os parâmetros marcados como traduzíveis serão apresentados ao tradutor. Isto é útil para os comandos de fonte. Estes comandos geralmente não devem ser separados dos seus parágrafos (para manter o contexto), mas não há motivo para chatear o tradutor com eles, se uma cadeia inteira é incluída em tal 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 [_]{_}
pt: O argumento I<parameters> é um conjunto de [] (para indicar um argumento opcional)
     ou {} (para indicar um argumento obrigatório).
    Pode pôr um traço baixo (_) entre estas chavetas para indicar isso 
    O parâmetro deve ser traduzido. Por exemplo:
     % po4a: command *chapter [_]{_}

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 {}{_}
pt: Isto indica que o comando capítulo tem dois parâmetros: um opcional
    (título curto) e um obrigatório, que devem ser ambos traduzidos.
    Se quer especificar que o comando 'href' tem dois parâmetros obrigatórios,
    que não quer traduzir o 'URL' (primeiro parâmetro) e que
    não quer que esse comando seja separado do seu parágrafo (que permitem
    ao tradutor mover a ligação (link) na frase), pode usar:
     %po4a: comando -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.
pt: Neste caso, a informação que indica quais argumentos devem ser traduzidos só é usada se um parágrafo é composto apenas por este comando href.

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
pt: Isso define os parâmetros aceites pelo ambiente I<ambiente> e especifica quais serão traduzidos.
    Essa informação é posteriormente usada para verificar a quantidade de argumentos
    do comando \begin.
    A sintaxe do argumento I<parâmetros> é a mesma da descrita para outros
    comandos.
    O primeiro parâmetro do comando \begin é o nome do ambiente.
    Este parâmetro não deve ser especificado na lista de parâmetros. Veja alguns
    exemplos:
     % 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.
pt: Como para os comandos, I<env> pode ser precedido por um sinal de mais (+) para indicar que o comando \begin deve ser traduzido com todos os seus argumentos.

note: type: textblock
en: Indicates that an environment should be split according to the given regular expression.
pt: Indica que um ambiente deve ser dividido de acordo com a expressão regular dada.

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.
pt: A expressão regular é delimitada por aspas. Ela não deveria criar qualquer referência própria.  Deveria usar (?:) se precisa de um grupo.   Também pode ser necessário alguns escapes.

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 '&').
pt: Por exemplo, o módulo LaTeX usa a "(:?&|\\\\)" expressão regular para traduzir separadamente cada célula de uma tabela (linhas são separadas por '\\' e por células por '&').

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}.
pt: A noção de ambiente é expandida ao tipo exibido no ficheiro PO. Isso pode ser usado para dividir em "\\\\" no primeiro argumento obrigatório no comando title. neste caso, o ambiente é title{#1}.

note: type: textblock
en: Indicate that I<env> is a verbatim environment.  Comments and commands will be ignored in this environment.
pt: Indica que I<env> é um ambiente literal.   Comentários e comandos serão ignorados neste ambiente.

note: type: =head1
en: WRITING DERIVATE MODULES
pt: ESCREVENDO MÓDULOS de DERIVA

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.
pt: Adiciona uma cadeia como um comentário a ser adicionado em torno do próximo elemento traduzido.  Isso é principalmente útil para o módulo texinfo, já que os comentários são tratados automaticamente no TeX.

note: type: textblock
en: Wrapper around Transtractor's translate, with pre- and post-processing filters.
pt: Envólucro em torno da tradução do Transtractor, com filtros pré e pós-processamento.

note: type: textblock
en: Comments of a paragraph are inserted as a PO comment for the first translated string of this paragraph.
pt: Comentários de um parágrafo são inseridos como um comentário PO para a primeira cadeia traduzida deste parágrafo.

note: type: textblock
en: This function returns:
pt: Esta função retorna:

note: type: =item
en: A command name
pt: Um nome de 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.
pt: Se nenhum comando é encontrado no início do 'buffer' dado, esta cadeia estará vazia. Apenas os comandos que podem ser separados são considerados. A cinza %separated_command contém a lista desses comandos.

note: type: =item
en: A variant
pt: Uma 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.
pt: Isto indica se uma variante é usada.  Por exemplo, um asterisco (*) pode ser adicionado no final das secções de comando para especificar que não devem ser numeradas. Neste caso, o campo irá conter "*".  Se não houver uma variante, o campo é uma cadeia vazia.

note: type: =item
en: An array of tuples (type of argument, argument)
pt: Uma matriz de tuplos (tipo de argumento, argumento)

note: type: textblock
en: The type of argument can be either '{' (for mandatory arguments) or '[' (for optional arguments).
pt: O tipo de argumento pode ser '{' (para argumentos obrigatórios) ou '[' (para argumentos opcionais).

note: type: =item
en: The remaining buffer
pt: O 'buffer' restante

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.
pt: O resto do 'buffer' após a remoção deste comando de liderança e os argumentos dele. Se nenhum comando for encontrado, o 'buffer' original não é tocado e retornado neste campo.

note: type: textblock
en: The same as B<get_leading_command>, but for commands at the end of a buffer.
pt: O mesmo que B<get_leading_command>, mas para comandos no fim dum 'buffer'.

note: type: textblock
en: Recursively translate a buffer by separating leading and trailing commands (those which should be translated separately) from the buffer.
pt: Recursivamente traduz um 'buffer' ao separar comandos à esquerda e à direita (aqueles que devem ser traduzidos em separado) a partir do '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().
pt: Se uma função é definida em %translate_buffer_env para o ambiente atual, esta função irá ser usada para converter o 'buffer' em vez de translate_buffer ().

note: type: textblock
en: Overloads Transtractor's read().
pt: Sobrecarrega o read() do 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.
pt: Recursivamente lê um ficheiro, anexando ficheiros incluídos que não estão listados na matriz @exclude_include. Ficheiros incluídos são pesquisados utilizando o comando B<kpsewhich> a partir da biblioteca kpathsea.

note: type: textblock
en: Except from the file inclusion part, it is a cut and paste from Transtractor's read.
pt: Com excepção da parte da inclusão do ficheiro, é um corte e cole a partir da leitura do Transtractor.

note: type: textblock
en: Subroutine for parsing a file with po4a directives (definitions for new commands).
pt: Sub-rotina para analisar um ficheiro com as diretivas po4a (definições de novos comandos).

note: type: textblock
en: Parse a definition line of the form "% po4a: ".
pt: Analisa uma linha de definição do formato "% po4a:".

note: type: textblock
en: See the B<INLINE CUSTOMIZATION> section for more details.
pt: Veja a secção B<INLINE CUSTOMIZATION> para mais detalhes.

note: type: =head1
en: INTERNAL FUNCTIONS used to write derivative parsers
pt: FUNÇÕES INTERNAS usadas para escrever analisadores derivados

note: type: textblock
en: Command and environment functions take the following arguments (in addition to the $self object):
pt: Funções de comando e ambiente que precisam dos seguintes argumentos (em adição do objeto $self):

note: type: =item
en: An array of (type, argument) tuples
pt: Uma matriz de tuplos (tipo, argumento)

note: type: =item
en: The current environment
pt: O ambiente atual

note: type: textblock
en: The first 3 arguments are extracted by get_leading_command or get_trailing_command.
pt: Os primeiros três argumentos são extraídos por get_leading_command ouget_trailing_command.

note: type: textblock
en: Command and environment functions return the translation of the command with its arguments and a new environment.
pt: Funções de comando e ambiente retornam a tradução do comando com os seus argumentos e um novo 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.
pt: Funções do ambiente são chamadas quando um comando \begin é encontrado. Eles são chamados com o comando \begin e os seus argumentos.

note: type: textblock
en: The TeX module only proposes one command function and one environment function: generic_command and generic_environment.
pt: O módulo TeX propõe apenas uma função de comando e uma função de 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>
pt: generic_command usa as informações especificadas por
    register_generic_command ou pela adição de definição para o ficheiro TeX:
     %po4a: comando I<command1> I<parameters>

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>
pt: generic_environment usa as informações especificadas por
    register_generic_environment ou pela adição de definição para o ficheiro TeX:
    %po4a: ambiente I<env> I<parameters>

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]).
pt: Ambas as funções só traduzem os parâmetros que foram especificados como traduzível (com um '_').  generic_environment irá acrescentar o nome do ambiente à pilha do ambiente e generic_command irá acrescentar o nome do comando seguido por um identificador do parâmetro (como {#7} ou [#2]).

note: type: textblock
en: This module needs more tests.
pt: Este módulo precisa de mais testes.

note: type: textblock
en: It was tested on a book and with the Python documentation.
pt: Ele foi testado num livro e com a documentação de Python.

note: type: =head1
en: TODO LIST
pt: LISTA de A FAZER

note: type: =item
en: Automatic detection of new commands
pt: Detecção automática de novos comandos

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.
pt: O módulo TeX pode analisar os argumentos do novo comando e tentar adivinhar a quantidade de argumentos, o tipo deles e se eles devem ou não ser traduzidos.

note: type: =item
en: Translation of the environment separator
pt: Tradução do separador de ambiente

note: type: textblock
en: When \item is used as an environment separator, the item argument is attached to the following string.
pt: Quando \item é utilizado como um separador de ambiente, o argumento item é ligado à seguinte cadeia.

note: type: =item
en: Some commands should be added to the environment stack
pt: Alguns comandos devem ser adicionados à pilha de 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.
pt: Estes comandos deveriam ser especificados por pares.  Isto pode ser usado para especificar comandos iniciando ou terminando um ambiente literal.

note: type: =item
en: Others
pt: Outros

note: type: textblock
en: Various other points are tagged TODO in the source.
pt: Vários outros pontos são marcados A FAZER na fonte.

note: type: =head1
en: KNOWN BUGS
pt: BUGS CONHECIDOS

note: type: textblock
en: Various points are tagged FIXME in the source.
pt: Vários pontos são marcados CORRIGIR na fonte.

note: type: textblock
en: Locale::Po4a::Texinfo - convert Texinfo documents and derivates from/to PO files
pt: Locale::Po4a::Texinfo - converte documentos Texinfo e derivados de/para ficheiros PO

note: type: textblock
en: Locale::Po4a::Texinfo is a module to help the translation of Texinfo documents into other [human] languages.
pt: Locale::Po4a::Texinfo é um módulo para ajudar a tradução de documentos Texinfo em outras línguas [humanas].

note: type: textblock
en: This module contains the definitions of common Texinfo commands and environments.
pt: Este módulo contém as definições dos comandos e ambientes comuns do Texinfo.

note: type: textblock
en: Only the comments starting with 'TRANSLATORS' are added to the PO files to guide the translators.
pt: Apenas os comentários que começam com "TRANSLATORS" são adicionados aos ficheiros PO para orientar os tradutores.

note: type: textblock
en: This module is still beta and not ready for production use.  Please send patches to contribute, not bug reports as we don't know how to deal with them.
pt: Este módulo ainda está na versão beta e não está pronto para uso em produção. Por favor, envie patches para contribuir, não relatórios de bugs, pois não sabemos como lidar com eles.

note: type: textblock
en: Do not warn about the current state of this module.
pt: Não avisa sobre o estado atual deste módulo.

note: type: textblock
en: Locale::Po4a::Text - convert text documents from/to PO files
pt: Locale::Po4a::Text - converte documentos de texto de/para ficheiros PO

note: type: textblock
en: Locale::Po4a::Text is a module to help the translation of text documents into other [human] languages.
pt: Locale::Po4a::Text é um módulo para ajudar na tradução de documentos de texto em outras línguas [humanas].

note: type: textblock
en: Paragraphs are split on empty lines (or lines containing only spaces or tabulations).
pt: Os parágrafos são divididos em linhas vazias (ou linhas que contém apenas espaços ou tabulações).

note: type: textblock
en: If a paragraph contains a line starting by a space (or tabulation), this paragraph won't be rewrapped.
pt: Se um parágrafo contém uma linha iniciada por um espaço (ou tabulação), este parágrafo não será re-envolvido.

note: type: textblock
en: Treat paragraphs that look like a colon-separated key-value pair as verbatim (with the C<no-wrap> flag in the PO file). A key-value pair string is a string like C<key: value>, 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.
pt: Trata como literais os parágrafos que se parecem com um par de valores-chave separados por dois pontos (com o sinalizador C<no-wrap> no ficheiro PO). Uma cadeia de par de valores-chave é uma cadeia como C<key: value>, contendo um ou mais caracteres diferentes de dois pontos e não de espaço seguidos por dois pontos seguidos por pelo menos um caractere não espacial antes do final da linha.

note: type: textblock
en: Deactivate the detection of bullets.
pt: Desativar a detecção de 'bullets'.

note: type: textblock
en: By default, when a bullet is detected, the bullet paragraph is not considered as a verbatim paragraph (with the C<no-wrap> flag in the PO file). Instead, the corresponding paragraph is rewrapped in the translation.
pt: Por predefinição, quando um marcador é detetado, um parágrafo de marcador não é considerado como um parágrafo literal (com a opção C<no-wrap> no ficheiro PO). Em vez disso, realiza-se nova quebra de linha no parágrafo correspondente na tradução.

note: type: textblock
en: Specify how tabulations shall be handled. The I<mode> can be any of:
pt: Especifica como tabulações devem ser tratadas. O I<mode> pode ser qualquer um de:

note: type: textblock
en: Lines with tabulations introduce breaks in the current paragraph.
pt: Linhas com tabulações apresentam quebras no parágrafo atual.

note: type: textblock
en: Paragraph containing tabulations will not be re-wrapped.
pt: Parágrafo a conter tabulações não será re-envolvido.

note: type: textblock
en: By default, tabulations are considered as spaces.
pt: Por predefinição, tabulações são consideradas como espaços.

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.
pt: Uma expressão regular correspondente a linhas que introduzem pausas. A regular expressão será ancorada de forma que toda a linha deve corresponder.

note: type: textblock
en: Handle the header and footer of released versions, which only contain non translatable information.
pt: Manipula o cabeçalho e rodapé das versões de lançamento, que só podem conter informações não traduzíveis.

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.
pt: Lida com o formato 'fortunes', que separa as 'fortunes' com uma linha que consiste em '%' ou '%%', e usa '%%' como o início de um comentário.

note: type: textblock
en: Handle some special markup in Markdown-formatted texts.
pt: Lida com alguma marcação especial em textos formatados em Markdown.

note: type: =item
en: B<yfm_keys> (markdown-only)
pt: B<yfm_keys> (somente Markdown)

note: type: =item
en: B<yfm_lenient> (markdown only)
pt: B<yfm_lenient> (somente 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.
pt: Permite que o analisador YAML Front Matter falhe em cabeçalhos malformados. Isto é particularmente útil quando o seu ficheiro começa com uma régua horizontal em vez de YAML Front Matter, mas insiste em usar três traços apenas para a sua régua.

note: type: =item
en: B<yfm_paths> (markdown only)
pt: B<yfm_paths> (somente Markdown)

note: type: =item
en: B<yfm_skip_array> (markdown-only)
pt: B<yfm_skip_array> (somente Markdown)

note: type: textblock
en: Handle Debian's control files.  A comma-separated list of fields to be translated can be provided.
pt: Lida com ficheiros control do Debian.  Pode ser fornecida uma lista separada por vírgulas com os campos a serem traduzidos.

note: type: textblock
en: Prevent po4a from wrapping any lines. This means that every content is handled verbatim, even simple paragraphs.
pt: Evita que po4a faça a quebra de qualquer linha. Isso significa que todo conteúdo é tratado literalmente, até mesmo parágrafos simples.

note: type: textblock
en: Tested successfully on simple text files and NEWS.Debian files.
pt: Testado com sucesso em ficheiros de texto simples e ficheiros NEWS.Debian.

note: type: textblock
en: Locale::Po4a::TransTractor - generic trans(lator ex)tractor.
pt: Locale::Po4a::TransTractor - trans(lator ex)trator tradutor extrator genérico.

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.
pt: Esta classe é o ancestral de todos os analisadores po4a usado para analisar um documento, para pesquisar cadeias traduzíveis, para extraí-las para um ficheiro PO e substitui-los pela tradução dela no documento resultante.

note: type: textblock
en: More formally, it takes the following arguments as input:
pt: Mais formalmente, recebe os seguintes argumentos como entrada:

note: type: textblock
en: a document to translate;
pt: um documento para traduzir;

note: type: textblock
en: a PO file containing the translations to use.
pt: Um ficheiro PO que contém as traduções para usar.

note: type: textblock
en: As output, it produces:
pt: Como saída, produz:

note: type: textblock
en: another PO file, resulting of the extraction of translatable strings from the input document;
pt: outro ficheiro PO, resultante da extração de cadeias traduzíveis no documento de entrada;

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.
pt: um documento traduzido, com a mesma estrutura que o da entrada, mas com todas as cadeias traduzíveis substituídas com as traduções encontradas no ficheiro PO fornecido na entrada.

note: type: textblock
en: Here is a graphical representation of this:
pt: Aqui está uma representação gráfica disto:

note: type: verbatim
en:    Input document --\                             /---> Output document
                         \                           /       (translated)
                          +-> parse() function -----+
                         /                           \
       Input PO --------/                             \---> Output PO
                                                             (extracted)
pt:    Documento de entrada --\                     / ---> documento de saída
                               \                   /          (traduzido)
                               +-> função analisar() ---+
                               /                         \
       Entrada PO ------------/                           \---> Saída PO
                                                                (extraído)

note: type: =head1
en: FUNCTIONS YOUR PARSER SHOULD OVERRIDE
pt: FUNÇÕES QUE O SEU ANALISADOR DEVE SOBREPOR

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.
pt: Este é o lugar onde todo o trabalho tem lugar: a análise dos documentos de entrada, a geração da saída e a extração das cadeias traduzíveis. Isto é muito simples de usar as funções disponíveis apresentadas na secção abaixo B<FUNÇÕES INTERNAS>. Veja também o B<RESUMO>, o qual apresenta um exemplo.

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.
pt: Esta função é invocada pela função process() abaixo, mas se escolher usar a função new() e, para adicionar conteúdo manualmente ao documento, terá que invocar esta função você mesmo.

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.
pt: Esta função retorna o cabeçalho que devemos acrescentar ao documento produzido, citado corretamente para ser um comentário na língua apontada.  Consulte a secção B<Educating developers about translations>, de L<po4a(7)|po4a.7>, que é para o bem de todos.

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.
pt: O exemplo a seguir analisa uma lista de parágrafos que começam com "<p>". Pelo bem da simplicidade, assumimos que o documento está bem formatado, ou seja, que etiquetas '<p> são as etiquetas apenas presentes e que esta marca é no início de cada parágrafo.

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.
pt: Depois de implementar a função de análise, pode usar a sua classe de documento, usando a interface pública apresentada na próxima secção.

note: type: =head1
en: PUBLIC INTERFACE for scripts using your parser
pt: INTERFACE PÚBLICA para scripts que usam o seu analisador

note: type: =head2
en: Constructor
pt: Construtor

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:
pt: Esta função pode fazer tudo o que precisa fazer com um documento po4a numa invocação. Os argumentos dela devem ser empacotados como uma 'hash'. AÇÕES:

note: type: textblock
en: Reads all the PO files specified in po_in_name
pt: Lê todos os ficheiros PO especificados em po_in_name

note: type: textblock
en: Reads all original documents specified in file_in_name
pt: Lê todos os documentos originais especificados em file_in_name

note: type: textblock
en: Parses the document
pt: Analisa o documento

note: type: textblock
en: Reads and applies all the addenda specified
pt: Lê e aplica todas as adendas especificadas

note: type: textblock
en: Writes the translated document to file_out_name (if given)
pt: Escreve o documento traduzido para o nome_ficheiro_saída (se dado)

note: type: textblock
en: Writes the extracted PO file to po_out_name (if given)
pt: Escreve o ficheiro PO extraído para nome_po_saída (se dado)

note: type: textblock
en: ARGUMENTS, beside the ones accepted by new() (with expected type):
pt: ARGUMENTOS, além daqueles aceites pelo new() (com o tipo esperado):

note: type: textblock
en: List of filenames where we should read the input document.
pt: Lista de nomes de ficheiros onde devemos ler o documento de entrada.

note: type: textblock
en: Charset used in the input document (if it isn't specified, use UTF-8).
pt: Conjunto de caracteres usado no documento de entrada (se não for especificado, usa UTF-8).

note: type: textblock
en: Filename where we should write the output document.
pt: Nome do ficheiro onde devemos escrever o documento de saída.

note: type: textblock
en: Charset used in the output document (if it isn't specified, use UTF-8).
pt: Conjunto de caracteres usado no documento de saída (se não for especificado, usa UTF-8).

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.
pt: Lista de nomes de ficheiros onde devemos ler os ficheiros de entrada do PO, que contêm a tradução que irá ser usada para traduzir o documento.

note: type: textblock
en: Filename where we should write the output PO file, containing the strings extracted from the input document.
pt: Nome do ficheiro onde devemos escrever a saída do ficheiro PO, que contém as cadeias extraídas do documento de entrada.

note: type: textblock
en: List of filenames where we should read the addenda from.
pt: Lista de nomes de ficheiros de onde devemos ler a adenda.

note: type: textblock
en: Charset for the addenda.
pt: Conjunto de caracteres para a adenda.

note: type: textblock
en: Create a new po4a document. Accepted options (in the hash passed as a parameter):
pt: Cria um novo documento de po4a. Opções aceites (no hash passado como parâmetro):

note: type: textblock
en: Sets the verbosity.
pt: Define o nível de detalhe.

note: type: textblock
en: Sets the debugging.
pt: Define a depuração.

note: type: textblock
en: The column at which we should wrap text in output document (default: 76).
pt: A coluna na qual devemos fazer a quebra de texto no documento de saída (predefinição: 76).

note: type: textblock
en: The negative value means not to wrap lines at all.
pt: O valor negativo significa não quebrar as linhas.

note: type: textblock
en: Also it accepts next options for underlying Po-files: B<porefs>, B<copyright-holder>, B<msgid-bugs-address>, B<package-name>, B<package-version>, B<wrap-po>.
pt: Também aceita as próximas opções para ficheiros PO subjacentes: B<porefs>, B<copyright-holder>, B<msgid-bugs-address>, B<package-name>, B<package-version>, B<wrap-po>.

note: type: =head2
en: Manipulating document files
pt: Manipulando ficheiros de documentos

note: type: textblock
en: Add another input document data at the end of the existing array C<< @{$self->{TT}{doc_in}} >>.
pt: Adiciona outros dados do documento de entrada no final da array existente C<< @{$self->{TT}{doc_in}} >>.

note: type: verbatim
en: This function takes two mandatory arguments and an optional one.
     * The filename to read on disk;
     * The name to use as filename when building the reference in the PO file;
     * The charset to use to read that file (UTF-8 by default)
pt: Esta função recebe dois argumentos obrigatórios e um opcional.
     * O nome do ficheiro a ser lido no disco;
     * O nome a ser usado como nome do ficheiro ao construir a referência no ficheiro PO;
     * O conjunto de caracteres a ser usado para ler esse ficheiro (UTF-8 por predefinição)

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).
pt: Esta matriz C<< @{$self->{TT}{doc_in}} >> detém os dados desse documento de
    entrada como uma matriz de cadeias com significados alternativos.
     * A cadeia C<$textline> que detém cada linha de dados de texto de entrada.
     * A cadeia C<< $filename:$linenum >> que detém a sua localização e chamada
       como "referência" (C<linenum> starts with 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.
pt: Por favor, note que ele não analisa nada. Deve usar a função parse() quando está feito com o empacotamento de ficheiros de entrada no documento.

note: type: textblock
en: Write the translated document to the given filename.
pt: Escreva o documento traduzido no nome do ficheiro dado.

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.
pt: Os dados desse documento traduzido são fornecidos por:
     * C<< $self->docheader() >> a deter o texto de cabeçalho para o plugin e
     * C<< @{$self->{TT}{doc_out}} >> a deter cada linha do principal texto traduzido na matriz.

note: type: =head2
en: Manipulating PO files
pt: Manipulando ficheiros 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.
pt: Adiciona o conteúdo dum ficheiro (que o nome é passado como argumento) para o actual PO de entrada. O conteúdo antigo não é descartado.

note: type: textblock
en: Write the extracted PO file to the given filename.
pt: Gravar o ficheiro PO extraído no nome do ficheiro dado.

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:
pt: Retorna algumas estatísticas sobre a tradução feita até agora. Note que não é a mesma estatística que aquela escrita por msgfmt--statistic. Aqui, são estatísticas sobre o uso recente do ficheiro PO, enquanto msgfmt relata o estado do ficheiro. Ele é um envolvido para função Locale::Po4a::Po::stats_get aplicada ao ficheiro de entrada PO. Exemplo de uso:

note: type: verbatim
en:     [normal use of the po4a document...]
    
        ($percent,$hit,$queries) = $document->stats();
        print "We found translations for $percent\%  ($hit from $queries) of strings.\n";
pt:     [uso normal do documento po4a...]
    
        ($percent,$hit,$queries) = $document->stats();
        print "Encontramos traduções para $percent\%  ($hit from $queries) de cadeias.\n";

note: type: =head2
en: Manipulating addenda
pt: Manipulando a adenda

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 ;)
pt: Por favor, consulte L<po4a(7)|po4a.7> para obter mais informações sobre o que são adendas e como os tradutores devem escrevê-las. Para aplicar uma adenda ao documento traduzido, basta passar o nome do ficheiro para esta função e está feito ;)

note: type: textblock
en: This function returns a non-null integer on error.
pt: Esta função retorna um inteiro não nulo em caso de erro.

note: type: =head2
en: Getting input, providing output
pt: Obter a entrada, fornecer a saída

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.
pt: Quatro funções são fornecidas para obter entrada e retornar a saída. Elas são muito parecidas com shift/unshift e push/pop de 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.
pt:  * Perl shift retorna o primeiro item da matriz e solta-o da matriz.
    * Perl unshift preenche um item da matriz como o primeiro item da matriz.
    * Perl pop retorna o último item da matriz e solta-o da matriz.
    * Perl push acrescenta um item da matriz como o último item da matriz.

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.
pt: O primeiro par é sobre entrada, enquanto ao segundo é sobre saída. Mnemônico: na entrada, está interessada na primeira linha, que é o que o shift fornece e na saída quer adicionar o seu resultado ao final, como o push faz.

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 >>.
pt: Esta função retorna a primeira linha a ser analisada e a referência dele correspondente (empacotada como uma matriz) da matriz C<< @{$self->{TT}{doc_in}} >> e descarta estes 2 primeiros itens da matriz. Aqui, a referência é fornecida por uma cadeia 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}} >>.
pt: Desloca a última linha deslocada do documento de entrada e a referência dele correspondente de volta ao cabeçalho de C<< {$self->{TT}{doc_in}} >>.

note: type: textblock
en: Push a new line to the end of C<< {$self->{TT}{doc_out}} >>.
pt: Força uma nova linha no fim de C<< {$self->{TT}{doc_out}} >>.

note: type: textblock
en: Pop the last pushed line from the end of C<< {$self->{TT}{doc_out}} >>.
pt: Estoira a última linha forçada do final de C<< {$self->{TT}{doc_out}} >>.

note: type: =head2
en: Marking strings as translatable
pt: Marcando cadeias como traduzíveis

note: type: textblock
en: One function is provided to handle the text which should be translated.
pt: Uma função é fornecida para lidar com o texto que deve ser traduzido.

note: type: textblock
en: Mandatory arguments:
pt: Argumentos obrigatórios:

note: type: textblock
en: A string to translate
pt: Uma cadeia para traduzir

note: type: textblock
en: The reference of this string (i.e. position in inputfile)
pt: A referência desta cadeia (ou seja, posição no ficheiro de entrada)

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?>)
pt: O tipo desta cadeia (ou seja, a descrição textual do papel estrutural dele; usado em Locale::Po4a::Po::gettextization(); ver também L<po4a(7)|po4a.7>, secção B<Gettextization: how does it work?>)

note: type: textblock
en: This function can also take some extra arguments. They must be organized as a hash. For example:
pt: Esta função também pode ter alguns argumentos extras. Eles devem ser organizadas como uma 'hash'. Um exemplo:

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.
pt: booleano que indica se podemos considerar que os espaços em branco na cadeia não são importantes. Se sim, a função canoniza a cadeia antes de procurar a tradução ou extraí-la, e envolve a tradução.

note: type: textblock
en: the column at which we should wrap (default: the value of B<wrapcol> specified during creation of the TransTractor or 76).
pt: a coluna na qual devemos fazer a quebra da linha (predefinição: o valor de B<wrapcol> especificado durante a criação do TransTractor ou 76).

note: type: textblock
en: The negative value will be substracted from the default.
pt: O valor negativo será subtraído da predefinição.

note: type: textblock
en: an extra comment to add to the entry.
pt: um comentário adicional para a entrada.

note: type: textblock
en: Actions:
pt: Ações:

note: type: textblock
en: Pushes the string, reference and type to po_out.
pt: Coloca a cadeia de referência e tipo em 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.
pt: Retorna a tradução da cadeia (como encontrada em po_in), de modo que o analisador pode construir o doc_out.

note: type: textblock
en: Handles the charsets to recode the strings before sending them to po_out and before returning the translations.
pt: Lida com os conjuntos de caracteres para recodificar as cadeias antes de as enviar para po_out e antes de voltar às traduções.

note: type: =head2
en: Misc functions
pt: Funções diversas

note: type: textblock
en: Returns if the verbose option was passed during the creation of the TransTractor.
pt: Retorna se a opção 'verbose' foi passada durante a criação do TransTractor.

note: type: textblock
en: Returns if the debug option was passed during the creation of the TransTractor.
pt: Retorna se a opção de depuração foi passada durante a criação doTransTractor.

note: type: textblock
en: This function return the charset that was provided as master charset
pt: Esta função retorna o charset que foi fornecido como o conjunto de caracteres mestre

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).
pt: Esta função irá retornar o conjunto de carácteres, que deviam ser usados na saída (em geral, útil para substituir os conjuntos de carácteres detetados à entrada do documento onde foi encontrado).

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.
pt: Vai usar o conjunto de caracteres de saída especificado na linha de comando. Se não fosse especificado, seria usado o conjunto de caracteres do PO de entrada e, se a entrada de PO tem o "CHARSET" predefinido, irá retornar um conjunto de carácteres do documento de entrada, de modo a que nenhuma codificação é realizada.

note: type: =head1
en: FUTURE DIRECTIONS
pt: DIREÇÕES FUTURAS

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.
pt: Uma falha do TransTractor atual é que ele não pode tratar de documentos traduzidos que contém todos os idiomas, como modelos debconf, ou ficheiros .desktop.

note: type: textblock
en: To address this problem, the only interface changes needed are:
pt: Para resolver este problema, as únicas mudanças na interface necessárias são:

note: type: textblock
en: take a hash as po_in_name (a list per language)
pt: obter um 'hash' como po_in_name (uma lista por idioma)

note: type: textblock
en: add an argument to translate to indicate the target language
pt: adicionar um argumento para traduzir para indicar a língua apontada

note: type: textblock
en: make a pushline_all function, which would make pushline of its content for all languages, using a map-like syntax:
pt: fazer uma função pushline_all, que deveria fazer pushline do conteúdo dele para todos idiomas, a usar uma sintaxe tipo mapa:

note: type: textblock
en: Will see if it's enough ;)
pt: Vamos ver se é suficiente ;)

note: type: textblock
en: Locale::Po4a::VimHelp - convert Vim help files from/to PO files.
pt: Locale::Po4a::VimHelp - converte ficheiros de ajuda Vim de/para ficheiros PO.

note: type: textblock
en: C<Locale::Po4a::VimHelp> is a module to help the translation of Vim help file.  See also L<Writing help files|https://vimhelp.org/helphelp.txt.html#help-writing> for its syntax.
pt: C<Locale::Po4a::VimHelp> é um módulo para ajudar a tradução do ficheiro de ajuda do Vim. Veja também L<Writing help files|https://vimhelp.org/helphelp.txt.html#help-writing> para a sua sintaxe.

note: type: textblock
en: This module is in an early stage of development.  It has been successfully tested on simple files like C<helphelp.txt>.  However, it has not yet been tested on full help files, and the way it parses them may change for fixes and improvements, especially paragraph wrapping.
pt: Este módulo está numa fase inicial de desenvolvimento. Foi testado com sucesso em ficheiros simples como C<helphelp.txt>. No entanto, ainda não foi testado em ficheiros de ajuda completa e a forma como analisá-los pode mudar para correções e melhorias, especialmente quebra de linha de parágrafos.

note: type: =head1
en: DEVELOPING
pt: DESENVOLVIMENTO

note: type: textblock
en: Parsing Vim help files for po4a is difficult.  Here are some obstacles while developing this module.  If you have a better idea, feel free to suggest a patch (with additional test cases).
pt: A análise de ficheiros de ajuda do Vim para po4a é difícil. Aqui estão alguns obstáculos ao desenvolver este módulo. Se tem uma ideia melhor, sinta-se livre para sugerir um patch (com casos de teste adicionais).

note: type: =item
en: C<1. foo> sounds like an ordered list
pt: C<1. foo> parece uma lista ordenada

note: type: textblock
en: Not necessarily.  Consider the following paragraph.
pt: Não necessariamente.  Considere o parágrafo seguinte.

note: type: textblock
en: For the same reason, what appears to be a heading (e.g. C<1.1 bar>) or an unordered list (e.g. C<o baz>) cannot be detected.
pt: Pela mesma razão, o que parece ser um cabeçalho (ex. C<1.1 bar>) ou uma lista não ordenada (ex. C<o baz>) não pode ser detetado.

note: type: =item
en: Flushed right tags should be excluded from translation target
pt: Etiquetas fluidas à direita devem ser excluídas do alvo de tradução

note: type: textblock
en: This topic is also difficult since it relates to language differences in localization.
pt: Este tópico também é difícil, uma vez que se relaciona com as diferenças linguísticas na localização.

note: type: textblock
en: Consider the following example.
pt: Considere o seguinte exemplo.

note: type: verbatim
en:  Such a common and short concept in some languages *tags*
pt:  Tal conceito comum e curto em alguns idiomas *tags*

note: type: textblock
en: which might be translated to
pt: que pode ser traduzido para

note: type: verbatim
en:  They are unfamiliar, there are no corresponding concepts and *tags*
     it takes a longer sentence to express them in this language
pt:  Eles são desconhecidos, não há conceitos correspondentes e *tags*
     precisa duma sentença mais longa para expressar neste idioma

note: type: textblock
en: When this happens, you have to decide at what point you want to add a tag I<nicely>.  This shouldn't be easy.  The Vim help file is in a hard wrapped format, even for parts that are not code blocks.
pt: Quando isto acontece, tem que decidir em que ponto quer adicionar uma tag I<de forma agradável>. Isto não deve ser fácil. O ficheiro de ajuda do Vim está num formato de quebra rígida, mesmo para partes que não são blocos de código.

note: type: textblock
en: The same applies to tag references such as C<|ref|>.
pt: O mesmo se aplica a referências de tags como C<|ref|>.

note: type: =item
en: Leveraging C<--wrapcol> to monitor text widths
pt: Nivelando C<--wrapcol> para larguras de monitor de texto

note: type: textblock
en: Using the C<--wrapcol> option to issue warnings when text width exceeds specified limits seems like a reasonable approach.  The official Vim help files feature a mode line, such as C<vim:tw=78:ts=8:noet:ft=help:norl:>, as seen in L<C<runtime/doc/if_perl.txt>|https://github.com/vim/vim/blob/04cc8975930b7b2c5d6753d3eddf57dab2816518/runtime/doc/if_perl.txt#L307>.  However, there are a few challenges to consider:
pt: Usar a opção C<--wrapcol> para emitir avisos quando a largura do texto excede os limites especificados parece ser uma abordagem razoável.  O Vim oficial apresenta um modo de linha, tal como C<vim:tw=78:ts=8:noet:ft=help:norl:>, como visto em L<C<runtime/doc/if_perl.txt>|https://github.com/vim/vim/blob/04cc8975930b7b2c5d6753d3eddf57dab2816518/runtime/doc/if_perl.txt#L307>.  No entanto, existem alguns desafios a considerar:

note: type: =item
en: File Parsing Behavior
pt: Comportamento de Análise do Ficheiro

note: type: textblock
en: If this option is implemented, it would be ideal to read the entire file first, detect whether the mode line exists, and determine which sections are affected.  Unfortunately, the progressive parsing mechanism is not employed in this case.
pt: Se esta opção for implementada, seria ideal ler o ficheiro inteiro primeiro, detetar se o modo de linha existe, e determinar que secções são afetadas.  Infelizmente, o mecanismo de análise progressivo não é empregado neste caso.

note: type: =item
en: Default vs. Custom Values
pt: Valores Predefinidos contra Personalizados

note: type: textblock
en: The generic default value of C<--wrapcol> is 76, whereas Vim help files commonly use 78.  In most cases, the value in the options passed to this module defaults to 76, but it is unclear whether this value was explicitly set or implicitly applied.
pt: O valor predefinido genérico do C<--wrapcol> é 76, onde os ficheiros de ajuda do Vim geralmente usam 78.  Na maioria dos casos, o valor das opções passadas a este módulo predefinem para 76, mas não é claro se este valor foi explicitamente definido ou implicitamente aplicado.

note: type: textblock
en: Locale::Po4a::Wml - convert WML (web markup language) documents from/to PO files
pt: Locale::Po4a::Wml - converte documentos WML (web markup language) de/a ficheiros 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.
pt: Locale::Po4a::Wml é um módulo para ajudar na tradução de documentos WML em outras línguas [humanas]. Não faça confusão com o WML que estamos a falar aqui (web markup language) e da porcaria WAP usado em telefones móveis.

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.
pt: Por favor note que este módulo conta com o módulo Locale::Po4a::Xhtml, que também conta com o módulo Locale::Po4a::Xml. Isto significa que todas as etiquetas para expressões de páginas web são assumidas, para serem escritas na sintaxe 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.
pt: Este módulo funciona para alguns documentos simples, mas ainda é jovem. Atualmente, o maior problema do módulo é provavelmente que não pode lidar com documentos que não contêm etiquetas em linha de formatação XML, como <email "foo@example.org">, que são frequentemente definidos na WML. Melhorias serão adicionadas em futuros lançamentos.

note: type: textblock
en: Locale::Po4a::Xhtml - convert XHTML documents from/to PO files
pt: Locale::Po4a::Xhtml - converte documentos XHTML de/para ficheiros PO

note: type: textblock
en: Locale::Po4a::Xhtml is a module to help the translation of XHTML documents into other [human] languages.
pt: Locale::Po4a::Xhtml é um módulo para ajudar a tradução de documentos XHTMLem outras línguas [humanas].

note: type: textblock
en: Include files specified by an include SSI (Server Side Includes) element (e.g. <!--#include virtual="/foo/bar.html" -->).
pt: Incluí ficheiros especificados por um elemento SSI incluído (Server Side Includes) (por exemplo <!--#include virtual="/foo/bar.html" -->).

note: type: textblock
en: B<Note:> You should use it only for static files.
pt: B<Note:> Deve usá-lo apenas para ficheiros estáticos.

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.
pt: Um parâmetro adicional I<rootpath> pode ser especificado. Especifica o caminho da raiz para encontrar ficheiros incluídos por um atributo B<virtual>.

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.
pt: "Funciona para mim", o que significa que o uso com sucesso no meu site pessoal. Porém, esse resultado pode variar dependendo do cenário: por favor, avise-me se alguma coisa não funcionar para si.

note: type: textblock
en: Locale::Po4a::Xml - convert XML documents and derivates from/to PO files
pt: Locale::Po4a::Xml - converte documentos XML e derivados de/para ficheiros 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.
pt: Locale::Po4a::Xml é um módulo para ajudar a tradução de documentos XML em outros idiomas [humanos]. Também pode ser usado como uma base para a construção de módulos de documentos com base em XML.

note: type: =head1
en: TRANSLATING WITH PO4A::XML
pt: TRADUZIR COM 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.
pt: Este módulo pode ser usado diretamente para lidar com documentos XML genéricos. Isto irá extrair todo o conteúdo das etiquetas e, e nenhum atributo, já que é onde o texto é escrito na maioria dos documentos com base 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.
pt: Existem algumas opções (descrito na próxima secção), que podem personalizar este comportamento. Se isto não se encaixa no seu formato de documento que está encorajado a escrever o seu próprio módulo derivado deste, para descrever os detalhes do seu formato. Consulte a secção B<WRITING DERIVATE MODULES> abaixo, para descrição do 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.
pt: A opção de depuração global faz com que este módulo mostre as cadeia excluídas, para ver se ele salta algo importante.

note: type: textblock
en: Prevents it to strip the spaces around the extracted strings.
pt: Impede-o para tirar os espaços em torno das cadeias extraídas.

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.
pt: Canoniza a cadeia para traduzir, a considerar que espaços em branco não são importantes e dimensiona o documento traduzido. Essa opção pode ser sobreposta por opções personalizadas de marcação. Veja a opção B<translated> abaixo.

note: type: textblock
en: Attributes are wrapped by default. This option disables wrapping.
pt: Atributos são envolvidos por predefinição. Essa opção desativa o envólucro.

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.
pt: Faz as etiquetas e atributos a procurar trabalhar de forma em maiúsculas e minúsculas. Se for definido, ele vai tratar E<lt>BooKe<gt>laNG e E<lt>BOOKE<gt>Lang como 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.
pt: Aspas de escape em cadeias de saída.  Necessário, por exemplo, para criação de recursos de cadeias para usar por ferramentas de compilação de Android.

note: type: textblock
en: See also: https://developer.android.com/guide/topics/resources/string-resource.html
pt: Veja também: 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.
pt: Quando definido, entidades externas estão incluídas no documento gerado (traduzido) e para a extração de cadeias. Se não for definido, vai ter que traduzir entidades externas separadamente como documentos independentes.

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:
pt: Esta opção define o comportamento do módulo quando ele encontrar uma sintaxe de XML inválida (uma etiqueta de fecho, que não coincide com a última etiqueta de abertura). Ele pode ter os seguintes valores:

note: type: textblock
en: This is the default value.  The module will exit with an error.
pt: Este é o valor predefinido. O módulo irá terminar com um erro.

note: type: textblock
en: The module will continue, and will issue a warning.
pt: O módulo irá continuar e emitir um aviso.

note: type: textblock
en: The module will continue without any warnings.
pt: O módulo vai continuar sem emitir nenhuns avisos.

note: type: textblock
en: Be careful when using this option.  It is generally recommended to fix the input file.
pt: Tenha cuidado ao usar esta opção. Recomenda-se geralmente para corrigir o ficheiro de entrada.

note: type: textblock
en: Note: This option is deprecated.
pt: Nota: Esta opção está obsoleta.

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.
pt: Extrai apenas as marcações especificadas na opção B<tags>.   Caso contrário, ela extrairá todas as marcações, com exceção daquelas especificadas.

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.
pt: A cadeias que vai tentar combinar com a primeira linha do doctype do documento (se definido). Se isso não acontecer, um aviso indicará que o documento poderá ser de um tipo incorreto.

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.
pt: A cadeia a indicar o caminho (por exemplo, E<lt>bbbE<gt>E<lt>AAAE<gt>) de uma etiqueta onde um atributo lang="..." deve ser adicionado. O idioma será definido como o nome base do ficheiro PO sem qualquer extensão .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>.
pt: Booleano indicando se as etiquetas de fecho são opcionais (como em HTML). Por predefinição, as etiquetas de fecho ausentes geram um erro tratado de acordo com B<ontagerror>.

note: type: textblock
en: Note: This option is deprecated.  You should use the B<translated> and B<untranslated> options instead.
pt: Nota: Esta opção está obsoleta.  Deve usar as opções B<translated> e B<untranslated> em vez desta.

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.
pt: Lista de etiquetas separadas por espaços que deseja traduzir ou ignorar. Por predefinição, as etiquetas especificadas serão excluídas, mas se usar a opção "tagsonly", etiquetas especificadas serão as únicas incluídas. As etiquetas devem estar em forma E<lt>aaaE<gt>, mas podem-se juntar a algum (E<lt>bbbE<gt>E<lt>aaaE<gt>) para dizer que o conteúdo da etiqueta E<lt>aaaE<gt> só será traduzido quando está numa etiqueta 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.
pt: Também pode especificar algumas opções de marcação para pôr alguns caracteres na frente da hierarquia de marcações. Por exemplo, pode pôr um I<w> (wrap) ou I<W> (não aplica wrap) para sobrescrever o comportamento predefinido especificado pela opção global B<wrap>.

note: type: textblock
en: Example: WE<lt>chapterE<gt>E<lt>titleE<gt>
pt: Exemplo: 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.
pt: Lista de atributos das etiquetas separadas por espaços que deseja traduzir. Pode especificar os atributos pelo nome deles (por exemplo, "lang"), mas pode prefixar com uma hierarquia de etiquetas, para especificar que este atributo só será traduzido quando está na etiqueta especificada. Por exemplo:E<lt>bbbE<gt>E<lt>aaaE<gt>lang especifica que o atributo lang só será traduzido se for numa etiqueta E<lt>aaaE<gt> e é numa etiqueta 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>.
pt: Não traduzir atributos em etiquetas em linha. Vez disso, substitua todos os atributos duma etiqueta por 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.
pt: Isto é útil quando atributos não serão traduzidas, como isso simplifica as cadeias para tradutores e evita erros de digitação.

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.
pt: Lista de etiquetas separadas por espaços que não deviam ser tratadas como etiquetas. Estas etiquetas são tradadas com em linha e, não precisam de ser fechadas.

note: type: textblock
en: Space-separated list of tags which should break the sequence.  By default, all tags break the sequence.
pt: Lista de etiquetas separadas por espaços que devem quebrar a sequência. Por predefinição, todas as etiquetas quebram a sequência.

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>).
pt: As etiquetas devem estar na forma <aaa>, mas pode juntar algumas (<bbb><aaa>), se a etiqueta (<aaa>) só deve ser considerada quando está em outra etiqueta (<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.
pt: Note que uma marcação deve ser listada em apenas uma cadeia de configuração de B<break>, B<inline> B<placeholder> ou B<customtag>.

note: type: textblock
en: Space-separated list of tags which should be treated as inline.  By default, all tags break the sequence.
pt: Lista de etiquetas separadas por espaços que devem ser tratadas como em linha. Por predefinição todas as etiquetas quebram a sequência.

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.
pt: Lista de etiquetas separadas por espaços que devem ser tratadas como espaços reservados. Os espaços reservados não quebram a sequência, mas o conteúdo dos espaços reservados é traduzido separadamente.

note: type: textblock
en: The location of the placeholder in its block will be marked with a string similar to:
pt: A localização do espaço reservado no bloco dele será marcado com uma cadeia semelhante 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.
pt: Por predefinição, as Instruções de Processamento (ou seja, tags C<E<lt>? ... ?E<gt>>) são tratadas como tags embutidas. Passe essa opção se desejar que as I.P. sejam tratadas como tag de quebra. Note que tags PHP não processadas são tratadas como Instruções de Processamento pelo analisador.

note: type: textblock
en: Space separated list of tags that the module should not try to set by default in any category.
pt: Lista de etiquetas separadas por espaços que o módulo não deve tentar definir por predefinição em nenhuma 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.
pt: Se tiver uma marcação que tenha a configuração predefinida dela pela subclasse deste módulo, mas desejar definir uma configuração alternativa, será necessário listar essa marcação como parte da cadeia de configuração 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).
pt: Diretivas de suporte do pré-processador C. Quando esta opção está definida, po4a irá considerar as diretivas de pré-processamento como separadores de parágrafo. Isso é importante se o ficheiro XML tiver de ser processado, porque senão as diretivas podem ser inseridas no meio de linhas se o po4a considerar que pertencem ao parágrafo corrente, que não será reconhecido pelo pré-processador. Nota: as diretivas de pré-processamento só devem aparecer entre etiquetas (não devem quebrar uma etiqueta).

note: type: textblock
en: Space-separated list of tags you want to translate.
pt: Listas de etiquetas separadas por espaços que quer traduzir.

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.
pt: Também pode especificar algumas opções de marcação para por alguns caracteres na frente da hierarquia de marcações. Isso sobrepõe o comportamento predefinido especificado pelas opções globais B<wrap> e B<defaulttranslateoption>.

note: type: textblock
en: Tags should be translated and content can be re-wrapped.
pt: Etiquetas devem ser traduzidas e o conteúdo pode ser re-envolvido.

note: type: textblock
en: Tags should be translated and content should not be re-wrapped.
pt: Etiquetas devem ser traduzidas e o conteúdo não deve ser re-envolvido.

note: type: textblock
en: Tags should be translated inline.
pt: As etiquetas devem ser traduzidas em linha.

note: type: textblock
en: Tags should be translated as placeholders.
pt: Etiquetas devem ser traduzidas como marcadores de posição.

note: type: textblock
en: Internally, the XML parser only cares about these four options: I<w> I<W> I<i> I<p>.
pt: Internamente, o analisador XML só se preocupa com essas quatro opções: 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.
pt: * As etiquetas listadas em B<break> são definidas como I<w> ou I<W> dependendo da opção B<wrap>.

note: type: textblock
en: * Tags listed in B<inline> are set to I<i>.
pt: * As etiquetas listadas em B<inline> são definidas como I<i>.

note: type: textblock
en: * Tags listed in B<placeholder> are set to I<p>.
pt: * As etiquetas listadas em B<placeholder> são definidas como I<p>.

note: type: textblock
en: * Tags listed in B<untranslated> are without any of these options set.
pt: * As etiquetas listadas em B<untranslated> não têm nenhuma dessas opções definidas.

note: type: textblock
en: You can verify actual internal parameter behavior by invoking B<po4a> with B<--debug> option.
pt: Pode verificar o comportamento real do parâmetro interno ao invocar B<po4a> com a opção B<--debug>.

note: type: textblock
en: Please note a tag should be listed in either B<translated> or B<untranslated> setting string.
pt: Note que uma marcação deve estar listada na cadeia de configuração B<translated> ou B<untranslated>.

note: type: textblock
en: Space-separated list of tags you do not want to translate.
pt: Listas de etiquetas separadas por espaços que não quer traduzir.

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.
pt: Note que uma etiqueta em linha traduzível numa etiqueta não traduzível é tratada como uma etiqueta de quebra traduzível, a configuração I<i> é descartada e I<w> ou I<W> é definido dependendo da opção B<wrap>.

note: type: textblock
en: The default categories for tags that are not in any of the translated, untranslated, break, inline, or placeholder.
pt: As categorias predefinidas para etiquetas que não são nenhuns de: traduzidos, não traduzidos, partidos, em linha ou espaço reservado.

note: type: textblock
en: This is a set of letters as defined in B<translated> and this setting is only valid for translatable tags.
pt: Este é um conjunto de letras, conforme definido em B<translated> e essa configuração é válida apenas para etiquetas traduzíveis.

note: type: =head1
en: WRITING DERIVATIVE MODULES
pt: ESCREVENDO MÓDULOS DERIVADOS

note: type: =head2
en: DEFINE WHAT TAGS AND ATTRIBUTES TO TRANSLATE
pt: DEFINIR QUE ETIQUETAS E ATRIBUTOS TRADUZIR

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:
pt: A mais simples personalização é definir quais as etiquetas e atributos mais desejados para o analisador traduzir. Isto deve ser feito na função 'initialize'. Primeiro, deve invocar o 'initialize' principal, para obter as opções de linha de comando e, em seguida, acrescentar as suas definições personalizadas para as opções de 'hash'. Se quiser tratar de algumas novas opções na linha de comando, deve defini-las antes invocar o 'initialize' principal:

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.
pt: Você deve usar as opções B<_default_inline>, B<_default_break>, B<_default_placeholder>, B<_default_translated>, B<_default_untranslated> e B<_default_attributes> nos módulos derivados. Isso permite que utilizadores sobreponham o comportamento predefinido definido no seu módulo com opções de linha de 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.
pt: Se não gostar do comportamento predefinido deste módulo xml e módulos derivados dele, poderá fornecer opções de linha de comando para alterar o comportamento deles.

note: type: textblock
en: See L<Locale::Po4a::Docbook(3pm)|Locale::Po4a::Docbook>,
pt: Veja L<Locale::Po4a::Docbook(3pm)|Locale::Po4a::Docbook>,

note: type: =head2
en: OVERRIDING THE found_string FUNCTION
pt: SOBREPONDO A FUNÇÃO found_string

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.
pt: Outro passo simples é sobrepor a função "found_string", que recebe as cadeias extraídas do analisador, a fim de traduzi-las. Lá pode controlar quais cadeias deseja traduzir e realizar neles as transformações antes ou depois da tradução em si.

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.
pt: Ele recebe o texto extraído, a referência de onde ele estava, e um 'hash' que contém informações extras para controlar que cadeias a traduzir, como traduzi-las e gerar o comentário.

note: type: textblock
en: The content of these options depends on the kind of string it is (specified in an entry of this hash):
pt: O conteúdo dessas opções depende do tipo de cadeia é (especificado numa entrada deste '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.
pt: A cadeia encontrada é o conteúdo de uma etiqueta traduzível. A entrada "tag_options" contém os caracteres de opção na frente da hierarquia das etiquetas no módulo "tags".

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.
pt: Significa que a cadeia encontrada é o valor de um atributo traduzível. A entrada "attribute" tem o nome do atributo.

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:
pt: Ela deve retornar o texto que irá substituir o original no documento traduzido. Aqui está um exemplo básico desta função:

note: type: textblock
en: There's another simple example in the new Dia module, which only filters some strings.
pt: Aqui está outro exemplo simples no novo módulo Dia , que só filtra algumas cadeias.

note: type: =head2
en: MODIFYING TAG TYPES (TODO)
pt: MODIFICANDO TIPOS DE ETIQUETAS (A FAZER)

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:
pt: Este é mais complexo, mas permite uma personalização (quase) total. É baseado numa lista de 'hashes', cada um define o comportamento de um tipo de etiqueta. A lista deve ser ordenada para que as etiquetas mais gerais estejam antes das mais concretas (ordenadas primeiro no início e, depois, pelas chaves de fecho). Para definir um tipo de etiqueta vai ter que fazer um hash com as seguintes chaves:

note: type: textblock
en: Specifies the beginning of the tag, after the "E<lt>".
pt: Especifica o princípio da etiqueta, depois de "E<lt>".

note: type: textblock
en: Specifies the end of the tag, before the "E<gt>".
pt: Especifica o fim da etiqueta, depois de "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.
pt: Diz que se esta é uma classe de etiquetas quebradas. Uma etiqueta não-quebrada (inline) é uma que pode ser tomada como parte do conteúdo de outra etiqueta. Pode levar o valor falso (0), verdadeiro (1) ou indefinido. Se deixá-lo indefinido, vai ter que definir a função f_breaking que vai dizer se uma etiqueta concreta desta classe é uma etiqueta de quebrar ou não.

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.
pt: É uma função que vai dizer se a próxima etiqueta é uma quebra ou não. Deve ser definida se a opção B<breaking> não é.

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.
pt: Se deixar esta chave indefinida, a função de extração de genéricos terá que extrair a própria etiqueta. É útil para as etiquetas que podem ter outras etiquetas ou estruturas especiais dentro delas, de modo que o analisador principal não fique louco. Esta função recebe um booleano que diz se a etiqueta deve ser removida do fluxo de entrada ou não.

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.
pt: Esta função recebe a etiqueta (no formato get_string_until()) e retorna a etiqueta traduzida (atributos traduzidos ou todos as necessárias transformações) como uma única cadeia.

note: type: =head2
en: WORKING WITH TAGS
pt: TRABALHANDO COM ETIQUETAS

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>.
pt: Esta função retorna o caminho para a etiqueta corrente a partir da raiz do documento no formato 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.
pt: Um conjunto adicional de etiquetas (sem parênteses) pode ser passado como argumento. Estes elementos de caminho são adicionados ao fim do caminho atual.

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.
pt: Esta função retorna o índice da lista tag_types que cabe na etiqueta seguinte no fluxo de entrada, ou -1, se está no fim do ficheiro de entrada.

note: type: textblock
en: Here, the tag has structure started by E<lt> and end by E<gt> and it can contain multiple lines.
pt: Aqui, a marcação tem estrutura iniciada por E<lt> e finalizada por E<gt> e pode conter várias linhas.

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($$) >>.
pt: Isso funciona na matriz C<< @{$self->{TT}{doc_in}} >> que detém os dados do documento de entrada e referência indiretamente via 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.
pt: Esta função retorna a próxima etiqueta do fluxo de entrada sem o início e o fim, numa forma de matriz, para manter as referências do ficheiro de entrada tem dois parâmetros: o tipo de etiqueta (como retornado por tag_type) e um booleano, que indica se deve ser removido a partir do fluxo de entrada.

note: type: textblock
en: This function returns the name of the tag passed as an argument, in the array form returned by extract_tag.
pt: Esta função retorna o nome da etiqueta passada como um argumento, no formato da matriz retornada por 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.
pt: Esta função retorna um booleano que diz que se a próxima etiqueta no fluxo de entrada é uma etiqueta quebrada ou não (etiqueta inline). Ela deixa o fluxo de entrada intacto.

note: type: textblock
en: This function translates the next tag from the input stream.  Using each tag type's custom translation functions.
pt: Essa função traduz a próxima etiqueta do fluxo de entrada. Usando funções de tradução personalizadas em cada tipo de etiqueta.

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).
pt: Esta função retorna um valor de cadeia que diz se o primeiro argumento (a hierarquia das etiquetas) corresponde a qualquer uma das etiquetas do segundo argumento (a lista de etiquetas ou a hierarquia). Se não corresponder, ele retorna 0. Caso contrário, retorna as opções de etiqueta correspondentes (os caracteres de frente da etiqueta) ou 1 (se a etiqueta não tiver opções).

note: type: =head2
en: WORKING WITH ATTRIBUTES
pt: TRABALHANDO COM ATRIBUTOS

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.
pt: Essa função manipula a tradução dos atributos das marcações. Ela recebe a marcação sem as marcas de início / fim e, então, ela encontra os atributos e traduz os traduzíveis (especificado pela opção do módulo B<attributes>). Isso retorna uma cadeia simples com a marcação traduzida.

note: type: =head2
en: WORKING WITH TAGGED CONTENTS
pt: TRABALHANDO COM CONTEÚDOS ETIQUETADOS

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.
pt: Essa função obtém o texto até a próxima marcação de quebra (não em linha) do fluxo de entrada. Traduz-a a usar as funções de tradução personalizadas de cada tipo de etiqueta.

note: type: =head2
en: WORKING WITH THE MODULE OPTIONS
pt: TRABALHANDO COM OPÇÕES DE MÓDULOS

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).
pt: Esta função preenche as estruturas internas que contêm as etiquetas, atributos e dados em linha com as opções do módulo (especificado na linha de comando ou na função de inicialização).

note: type: =head2
en: GETTING TEXT FROM THE INPUT DOCUMENT
pt: OBTER TEXTO A PARTIR DO DOCUMENTO DE ENTRADA

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.
pt: Esta função retorna uma matriz com as linhas (e referências) do documento de entrada até encontrar o primeiro argumento. O segundo argumento é um 'hash' de opções. Valor 0 significa desativado (a predefinição) e 1 ativado.

note: type: textblock
en: The valid options are:
pt: As opções válidas são:

note: type: textblock
en: This makes the returned array to contain the searched text
pt: Isto faz com que a matriz retornada contenha o texto procurado

note: type: textblock
en: This removes the returned stream from the input
pt: Isto remove o fluxo retornado a partir da entrada

note: type: textblock
en: This ensures that the searched text is outside any quotes
pt: Isto assegura que o text procurado está fora de qualquer citação

note: type: textblock
en: This denotes that the first argument is a regular expression rather than an plain string
pt: Isso indica que o primeiro argumento é uma expressão regular e não uma cadeia simples

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.
pt: Esta função recebe como argumento a referência a um parágrafo (no formato retornado por get_string_until), ignora os espaços de título dele e retorna-os como uma cadeia simples.

note: type: textblock
en: This function returns a simple string with the text from the argument array (discarding the references).
pt: Esta função retorna uma cadeia simples com o texto do argumento da matriz (descartando as referências).

note: type: textblock
en: This module can translate tags and attributes.
pt: Este módulo pode traduzir etiquetas e atributos.

note: type: textblock
en: DOCTYPE (ENTITIES)
pt: DOCTYPE (ENTIDADES)

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.
pt: Há um suporte mínimo para a tradução de entidades. Elas são traduzida como um todo e as etiquetas não são tidas em conta. As entidades multi linhas não são suportadas e as entidades são sempre re-envolvidas durante a tradução.

note: type: textblock
en: MODIFY TAG TYPES FROM INHERITED MODULES (move the tag_types structure inside the $self hash?)
pt: MODIFICAR TIPOS DE ETIQUETAS A PARTIR DE MÓDULOS HERDADOS (move a estrutura tag_types dentro de hash $self hash?)

note: type: textblock
en: Locale::Po4a::Yaml - convert YAML files from/to PO files
pt: Locale::Po4a::Yaml - converte ficheiros YAML de/para ficheiros PO

note: type: textblock
en: Locale::Po4a::Yaml is a module to help the translation of Yaml files into other [human] languages.
pt: Locale::Po4a::Yaml é um módulo para ajudar a tradução de ficheiros Yaml para outros idiomas [humanos].

note: type: textblock
en: The module extracts the value of YAML hashes and arrays. Hash keys are not extracted.
pt: O módulo extrai o valor de hashes e matrizes YAML. As chaves hash não são extraídas.

note: type: textblock
en: NOTE: This module parses the YAML file with YAML::Tiny.
pt: NOTA: Este módulo analisa o ficheiro YAML com 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.
pt: Lista separada por espaços de chaves hash para processar para extração; todas as outras chaves são ignoradas. As chaves são combinadas com uma correspondência que diferencia maiúsculas de minúsculas. Se B<paths> e B<keys> forem usadas juntas, os valores serão incluídos se forem correspondidos por pelo menos uma das opções. Os valores das matrizes sempre são retornados, a menos que a opção B<skip_array> seja fornecida.

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.
pt: Lista separada por espaços de caminhos hash para processar para extração; todos os outros caminhos são ignorados. Os caminhos são combinados com uma correspondência que diferencia maiúsculas de minúsculas. Se B<paths> e B<keys> forem usadas juntas, os valores serão incluídos se forem correspondidos por pelo menos uma das opções. Os valores das matrizes sempre são retornados, a menos que a opção B<skip_array> seja fornecida.

note: type: textblock
en: Do not translate array values.
pt: Não traduz os valores de matrizes.
