<?xml version="1.0" ?>
<!DOCTYPE book PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd" [
 <!ENTITY % Portuguese "INCLUDE">
 <!ENTITY % addindex "IGNORE">
]>

<book lang="&language;">

  <bookinfo>
    <title
>O Manual do Editor de Expressões Regulares</title>

    <authorgroup>
      <author
><firstname
>Jesper K.</firstname
> <surname
>Pedersen</surname
> <affiliation
><address
><email
>blackie@kde.org</email
></address
></affiliation>
      </author>
    </authorgroup>

    <date
>2001-07-03</date>
    <releaseinfo
>0.1</releaseinfo>

    <legalnotice
>&underFDL;</legalnotice>

    <copyright>
      <year
>2001</year>
      <holder
>Jesper K. Pedersen</holder>
    </copyright>

    <abstract>
      <para
>Este manual descreve o item gráfico do Editor de Expressões Regulares</para>
    </abstract>

    <keywordset>
      <keyword
>KDE</keyword>
      <keyword
>expressão regular</keyword>
    </keywordset>
  </bookinfo>

  <!-- ====================================================================== -->
  <!--                               Introduction                             -->
  <!-- ====================================================================== -->
  <chapter id="introduction">
    <title
>Introdução</title>


    <para
>O editor de expressões regulares é um editor para criar uma expressão regular de uma forma gráfica (em contraste com a sintaxe em <acronym
>ASCII</acronym
>). Tradicionalmente, as expressões regulares têm sido escritas com a sintaxe de <acronym
>ASCII</acronym
>, a qual se assemelha, por exemplo, a <literal
>^.*kde\b</literal
>. A maior desvantagem deste estilo é: <itemizedlist>
        <listitem
><para
>É difícil de compreender pelos não-programadores.</para
></listitem>

        <listitem
><para
>Obriga a que você <emphasis
>escape</emphasis
> ou <emphasis
>comente</emphasis
> alguns símbolos (para corresponder com um asterisco, por exemplo, você tem de escrever <literal
>\*</literal
>). </para
></listitem>

        <listitem
><para
>Obriga a que você se recorde das regras para a <emphasis
>precedência</emphasis
> (A que é que corresponde o <literal
>x|y*</literal
>? A um único <literal
>x</literal
> ou um conjunto de <literal
>y</literal
>s, <emphasis
>OU</emphasis
>, por sua vez, um conjunto de <literal
>x</literal
>s e <literal
>y</literal
>s misturados?)</para
></listitem>
      </itemizedlist>
    </para>

    <para
>O editor de expressões regulares, por outro lado, permite-lhe <emphasis
>desenhar</emphasis
> a sua expressão regular de uma forma não-ambígua. O editor resolve, pelo menos, os itens 2 e 3 descritos acima. Pode não tornar as expressões regulares disponíveis para os não-programadores, ainda que só os testes pelos utilizadores possam confirmar isso. Por isso, se você for um não-programador e tiver ganho o poder das expressões regulares com este editor, então <ulink url="mailto:blackie@kde.org"
>comunique-me esse facto</ulink
>. </para>

  </chapter>

  <!-- ====================================================================== -->
  <!--                       What is a Regular Expression                     -->
  <!-- ====================================================================== -->
  <chapter id="whatIsARegExp">
    <title
>O Que é Uma Expressão Regular</title>

    <para
>A expressão regular é uma forma de indicar as <emphasis
>condições</emphasis
> a cumprir para uma dada situação em mente. Normalmente, quando você procura num editor de texto, você indica o texto a procurar <emphasis
>literalmente</emphasis
>; se usar expressões regulares, por outro lado, você diz como é que uma ocorrência se poderá parecer. Alguns exemplos disto incluem <emphasis
>Estou à procura da palavra KDE, mas só no início da linha</emphasis
> ou <emphasis
>Estou à procura da palavra <literal
>a</literal
>, mas tem de existir isolada</emphasis
> ou ainda <emphasis
>Estou à procura dos ficheiros que comecem pela palavra <literal
>teste</literal
>, seguida de um conjunto de algarismos, como por exemplo <literal
>teste12</literal
>, <literal
>teste107</literal
> e <literal
>teste007</literal
></emphasis
></para>

    <para
>Você constrói as expressões regulares a partir de sub-expressões, tal como você constrói os brinquedos grandes de Lego a partir de peças mais pequenas. Tal como no mundo do Lego, também existe um conjunto de peças básicas. A seguir será descrita cada uma dessas "peças de construção" usando um conjunto de exemplos.</para>

    <example>
      <title
>Procurar por texto normal.</title>
      <para
>Se você quiser procurar apenas um dado texto, então a expressão regular não é de facto a melhor escolha. A razão para tal é que as expressões regulares atribuem um significado especial a alguns caracteres. Isto inclui os seguintes caracteres: <literal
>.*|$</literal
>. Por isso, se quiser procurar pelo texto <literal
>kde.</literal
> (i.e. os caracteres <literal
>kde</literal
> seguidos de um ponto), então você teria de indicar isto assim: <literal
>kde\.</literal
><footnote
><para
>O editor de expressões regulares resolve este problema ao tratar das regras de escape por si.</para
></footnote
> Se escrever <literal
>\.</literal
> em vez de <literal
>.</literal
> é chamado de <emphasis
>escape</emphasis
>. </para>
    </example>

    <example id="positionregexp">
      <title
>Correspondência com URL's</title>
      <para
>Quando você selecciona algo que se assemelha a um URL no KDE, aí o programa <command
>klipper</command
> oferecer-se-á para iniciar o <command
>konqueror</command
> com o URL seleccionado.</para>

      <para
>O <command
>Klipper</command
> faz isto ao fazer uma correspondência do texto seleccionado ou da área de transferência com várias expressões regulares diferentes; quando uma das expressões regulares fizer correspondência, o comando correspondente será despoletado.</para>
      
      <para
>A expressão regular para os URLs diz (entre outras coisas), que o texto deverá começar por <literal
>http://</literal
>. Isto é descrito com base nas expressões regulares antecedendo o texto <literal
>http://</literal
> com um acento circunflexo (o carácter <literal
>^</literal
>).</para>

      <para
>O exemplo acima serve para marcar as posições com expressões regulares. De forma semelhante, a posição do <emphasis
>fim de linha</emphasis
> poderá ser correspondida com o <literal
>$</literal
> (i.e., um símbolo de cifrão).</para>
    </example>

    <example id="boundaryregexp">
      <title
>Se procurar pela palavra <literal
>a</literal
>, mas não por <emphasis
>a</emphasis
><literal
>í</literal
>, <literal
>a</literal
><emphasis
>ndar</emphasis
> ou <literal
>outr</literal
><emphasis
>a</emphasis
><literal
>s</literal
></title>
      <para
>Dois tipos extra de posições podem ser correspondências na forma acima, nomeadamente <emphasis
>a posição no limite de uma palavra</emphasis
> e a <emphasis
>posição no limite de uma <emphasis
>não</emphasis
>-palavra</emphasis
>. As posições são indicadas usando o texto <literal
>\b</literal
> (para os limites das palavras), e o <literal
>\B</literal
> (para os limites de sequências que não são palavras)<emphasis
></emphasis
></para>

      <para
>Assim, se procurar pela palavra <literal
>a</literal
>, pode fazê-lo com a expressão regular <literal
>\ba\b</literal
>. Isto indica que você está à procura da palavra <literal
>a</literal
> sem letras nenhumas de cada lado dela (i.e., com o limite de uma palavra de cada lado).</para>

      <para
>As quatro de expressões regulares de correspondências de posições são introduzidas no editor de expressões regulares usando a <link linkend="positiontool"
>ferramenta de quatro posições diferentes</link
></para>
    </example>

    <example id="altnregexp">
      <title
>Procurar tanto por <literal
>isto</literal
> como por <literal
>aquilo</literal
></title>
      <para
>Imagine que quer percorrer o seu documento à procura tanto da palavra <literal
>isto</literal
> como da palavra <literal
>aquilo</literal
>. Com um método de procura normal, você conseguiria fazer em duas tentativas, sendo que na primeira iria procurar por <literal
>isto</literal
> e na segunda iria procurar por <literal
>aquilo</literal
>.</para>

      <para
>Ao usar as pesquisas usando as expressões regulares, você iria procurar por ambas as sequências de uma vez. Você faria isso ao procurar por <literal
>isto|aquilo</literal
>, isto é, separando as sequências por uma barra vertical.<footnote
><para
>Repare que em cada lado da barra vertical existe uma expressão regular, como tal esta funcionalidade não se aplica apenas para procurar dois pedaços de texto diferentes, mas sim para procurar duas expressões regulares diferentes.</para
></footnote
></para>

      <para
>No editor de expressões regulares você não escreve por si próprio a barra vertical, mas sim selecciona a <link linkend="altntool"
>ferramenta de alternativas</link
>, introduzindo as sub-expressões regulares uma por cima da outra.</para>
    </example>

    <example id="repeatregexp">
      <title
>Corresponder a tudo</title>
      <para
>As expressões regulares são frequentemente comparadas com os caracteres especiais existentes também na linha de comandos - esta é a capacidade de indicar um conjunto de ficheiros com o asterisco. Você irá provavelmente reconhecer a correspondência com os caracteres especiais a partir dos exemplos seguintes: <itemizedlist>
          <listitem
><para
><literal
>ls *.txt</literal
> - aqui o <literal
>*.txt</literal
> corresponderá a todos os ficheiros que terminem na extensão <literal
>.txt</literal
>.</para
></listitem>
          <listitem
><para
><literal
>cat teste??.res</literal
> - corresponde a todos os ficheiros que comecem por <literal
>teste</literal
>, seguido de dois caracteres quaisquer, terminando finalmente em <literal
>.res</literal
></para
></listitem>
        </itemizedlist>
      </para>

      <para
>Na linha de comandos o asterisco corresponde a qualquer carácter, segundo uma quantidade qualquer. Por outras palavras, o asterisco corresponde a <emphasis
>tudo</emphasis
>. Isto é escrito com o formato <literal
>.*</literal
> na sintaxe das expressões regulares. O ponto corresponde a um carácter qualquer, individualmente, isto é, a apenas <emphasis
>um</emphasis
> carácter, enquanto que o asterisco indica que a expressão anterior a ele deverá ter uma correspondência repetida por várias vezes. Em conjunto, isto diz que corresponde a qualquer conjunto de caracteres arbitrários com tamanho também arbitrário.</para>

      <para
>Isto poderá parecer mais ou menos complicado, mas quando tiver uma ideia global, irá ver o seu poder. Deixe que lhe seja mostrada outra expressão regular básica: o <literal
>e</literal
>. A letra <literal
>e</literal
> por si só é uma expressão regular que corresponde a uma única letra, nomeadamente a letra <literal
>e</literal
>. Se combinar isto com o asterisco, i.e., <literal
>e*</literal
>, então obter-se-á uma expressão regular que irá corresponder a uma quantidade arbitrária de e's.</para>

      <para
>Podem-se combinar várias expressões regulares, umas a seguir às outras, como por exemplo <literal
>ba(na)*</literal
>. <footnote
><para
>O <literal
>(na)*</literal
> apenas diz que o que se encontra dentro de parêntesis é repetido um dado número qualquer de vezes.</para
></footnote
> Imagine que você escreveu esta expressão regular no campo de procura de um editor de texto; nesse caso iria obter as seguintes palavras (entre outras): <literal
>ba</literal
>, <literal
>bana</literal
>, <literal
>banana</literal
>, <literal
>bananananananana</literal
> </para>

      <para
>Dada a informação acima, espera-se que não seja difícil para si escrever a sequência da linha de comandos <literal
>teste??.res</literal
> como uma expressão regular. A resposta é: <literal
>teste..\.res</literal
>. O ponto por si só significa qualquer carácter. Para corresponder a um único ponto você precisa de escrever <literal
>\.</literal
><footnote
><para
>Isto corresponder a 'escapar'.</para
></footnote
>. Por outras palavras, a expressão regular <literal
>\.</literal
> corresponde a um ponto, enquanto que um ponto sozinho corresponde a qualquer carácter. </para>

      <para
>No editor de expressões regulares, a expressão regular repetida é criada através da <link linkend="repeattool"
>ferramenta de repetição</link
> </para>
    </example>

    <example id="lookaheadregexp">
      <title
>Substituir o <literal
>&amp;</literal
> por <literal
>&amp;amp;</literal
> num documento de HTML</title
> <para
>No HTML, o carácter especial <literal
>&amp;</literal
> deverá ser escrito como <literal
>&amp;amp;</literal
> - isto assemelha-se a 'escapar' nas expressões regulares.</para>

      <para
>Imagine que escreveu um documento em HTML num editor normal (p.ex., o XEmacs ou o Kate), e se esqueceu por completo desta regra. O que você teria de fazer ao descobrir o seu erro seria substituir todas as ocorrências de <literal
>&amp;</literal
> por <literal
>&amp;amp;</literal
>.</para>

      <para
>Isto pode ser feito facilmente usando a procura e substituição normais, só que existe, contudo, um pormenor. Imagine que se lembrou de facto desta regra - <emphasis
>só um bocadinho</emphasis
> - e que resultava em alguns pontos. A substituição incondicional iria resultar em que o <literal
>&amp;amp;</literal
> seria substituído por <literal
>&amp;amp;amp;</literal
></para>

      <para
>O que você queria mesmo dizer era que o <literal
>&amp;</literal
> só deveria ser colocado se <emphasis
>não</emphasis
> fosse seguido pelas letras <literal
>amp;</literal
>. Você pode fazer isto usando expressões regulares com <emphasis
>leitura antecipada positiva</emphasis
>. </para>

      <para
>A expressão regular que só faria corresponder o 'e comercial' se não for seguido das letras <literal
>amp;</literal
> assemelha-se ao seguinte: <literal
>&amp;(?!amp;)</literal
>. Isto é, obviamente, mais simples de ler usando o editor de expressões regulares, onde você iria utilizar as <link linkend="lookaheadtools"
>ferramentas de leitura antecipada</link
>.</para>
    </example>

  </chapter>

  <!-- ====================================================================== -->
  <!--                    Using the Regular Expression Editor                 -->
  <!-- ====================================================================== -->
  <chapter id="theEditor">
    <title
>Usar o Editor de Expressões Regulares</title>

    <para
>Este capítulo explicar-lhe-á como o editor de expressões regulares funciona. </para>

    <!-- ====================================================================== -->
    <!--                   The organization of the screen                       -->
    <!-- ====================================================================== -->
    <sect1 id="screenorganization">
      <title
>A organização do ecrã</title>

      <mediaobject>
        <imageobject
><imagedata format="PNG" fileref="theEditor.png"/></imageobject>
      </mediaobject>
      
      <para
>A componente mais importante do editor é, como será de esperar, a área de edição; esta é a área onde você desenha a sua expressão regular. A área em questão é a zona acinzentada no meio.</para>

      <para
>Por cima da área de edição existem duas barras de ferramentas, onde a primeira contém as <link linkend="editingtools"
>acções de edição</link
> - muito parecidas com as ferramentas de desenho num programa de desenho. A segunda barra de ferramentas contém o botão de <emphasis
>o que é isto</emphasis
>, assim como os botões para desfazer e refazer.</para>

      <para
></para>

      <para
>Sob a área de edição é possível encontrar a expressão regular construída neste momento, descrita na sintaxe denominada por ASCII. A sintaxe de ASCII é actualizada enquanto você edita a expressão regular no editor gráfico. Se você quiser, por outro lado, actualizar a sintaxe de ASCII está à vontade para o fazer; nesse caso, o editor gráfico actualiza-se na altura para reflectir as suas alterações.</para>

      <para
>Finalmente, à esquerda da área de edição, você encontra um conjunto de expressões regulares pré-concebidas. Estas servem para dois fins: (1) Quando você carregar o editor com uma expressão regular, então esta é tornada <emphasis
>mais bonita</emphasis
> ou mais compreensível se substituir as expressões regulares comuns. No resultado do ecrã acima, você pode ver como é que a sintaxe ASCII foi substituída por uma caixa que diz "tudo". (2) Quando você introduz expressões regulares, poderá encontrar um conjunto de peças de construção para a sua própria expressão regular a partir do conjunto de expressões regulares predefinidas. Veja a secção sobre as <link linkend="userdefinedregexps"
>expressões regulares definidas pelo utilizador</link
> para aprender como gravar as suas próprias expressões regulares.</para
>      
    </sect1>

    <!-- ====================================================================== -->
    <!--                         Editing Tools                                  -->
    <!-- ====================================================================== -->
    <sect1 id="editingtools">
      <title
>Ferramentas de Edição</title>
      <para
>O texto nesta secção espera que você tenha lido o capítulo sobre <link linkend="whatIsARegExp"
>o que é uma expressão regular</link
> ou que tenha algum conhecimento prévio sobre o assunto.</para>
      
      <para
>Todas as ferramentas de edição estão localizadas na barra de ferramentas por cima da área de edição. Cada uma delas será descrita a seguir.</para>
      
      

      <simplesect id="selecttool">
        <title
>Ferramenta de Selecção</title>
	<mediaobject>
            <imageobject
><imagedata format="PNG" fileref="select.png"/>
        </imageobject
></mediaobject>
        <para
>A ferramenta de selecção é usada para marcar os elementos para as operações de cortar-e-colar e de arrastar-e-largar. Isto é muito semelhante à ferramenta de selecção num programa de desenho.</para>
      </simplesect>
        
      

      <simplesect id="texttool"
><title
>Ferramenta de Texto</title>
      <mediaobject>
      <imageobject>
	    <imagedata format="PNG" fileref="text.png"/>
	</imageobject
></mediaobject>
		        
        <para
><inlinemediaobject
><imageobject>
              <imagedata format="PNG" fileref="texttool.png"/>
        </imageobject
></inlinemediaobject
></para>

        <para
>Se usar esta ferramenta você irá introduzir algum texto normal com o qual irá fazer a correspondência. O texto é correspondido literalmente, i.e., você não terá que escapar os caracteres especiais. No exemplo acima, a seguinte expressão regular será criada: <literal
>abc\*\\\)</literal
></para>
      </simplesect>

      

      <simplesect id="characterstool"
><title
>Ferramenta de Caracteres</title>
      <mediaobject
><imageobject>
            <imagedata format="PNG" fileref="characters.png"/>
            </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject>
            <imagedata format="PNG" fileref="charactertool.png"/>
            </imageobject
></inlinemediaobject
></para>
        
        <para
>Se usar esta ferramenta, você irá introduzir gamas de caracteres. Os exemplos incluem que o texto ASCII diz <literal
>[0-9]</literal
> e <literal
>[^a-zA-Z,_]</literal
>. Ao introduzir um item com esta ferramenta, aparecerá uma janela na qual você poderá indicar as gamas ou intervalos de caracteres.</para>
        
        <para
>Veja a descrição das <link linkend="repeatregexp"
>expressões regulares repetidas</link
>.</para>
      </simplesect>

      
      
      <simplesect id="anychartool"
><title
>Ferramenta para Qualquer Carácter</title>
        <mediaobject
><imageobject>
              <imagedata format="PNG" fileref="anychar.png"/>
        </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject
><imagedata format="PNG" fileref="anychartool.png"/>
        </imageobject
></inlinemediaobject
></para>

        <para
>Esta é a expressão regular do "ponto" (.). Esta aceita qualquer caracter isolado.</para
> 
        
       
        
        </simplesect>



      <simplesect id="repeattool"
><title
>Ferramenta de Repetição</title>
      <mediaobject
><imageobject>
            <imagedata format="PNG" fileref="repeat.png"/>
            </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject>
            <imagedata format="PNG" fileref="repeattool.png"/>
            </imageobject
></inlinemediaobject
></para>

        <para
>Isto corresponde aos elementos repetidos. Isto inclui o que, na sintaxe ASCII, é representado usando um asterisco (*), um sinal de mais (+), um ponto de interrogação (?) e os intervalos ({3,5}). Quando introduzir um item com esta ferramenta, aparecerá uma janela que irá perguntar quantas vezes terá a repetição.</para>
          
          <para
>Você indica o que deseja repetir ao desenhar o conteúdo repetido dentro da caixa que esta ferramenta introduz.</para>

          <para
>Os elementos repetidos podem tanto ser construídos de dentro para fora como vice-versa. Isto significa que você pode desenhar primeiro o que será repetido, seleccioná-lo e usar a ferramenta de repetição para o replicar ou, em alternativa, pode indicar primeiro o número de repetições e desenhar o que se pretende repetir dentro dele.</para>

        <para
>Veja a descrição sobre as <link linkend="repeatregexp"
>expressões regulares repetidas</link
>.</para>
        </simplesect>




      <simplesect id="altntool"
><title
>Ferramenta de Alternativas</title>
      <mediaobject
><imageobject>
            <imagedata format="PNG" fileref="altn.png"/>
            </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject
><imagedata format="PNG" fileref="altntool.png"/>
        </imageobject
></inlinemediaobject
></para>
        
        <para
>Esta é a expressão regular para as alternativas (|). Você indica as alternativas quando desenha cada uma delas por cima da anteriores dentro da caixa que esta ferramenta introduz.</para>

        <para
>Veja a descrição sobre as <link linkend="altnregexp"
>expressões regulares para as alternativas</link
></para>
      </simplesect>
      



      <simplesect id="compoundtool"
><title
>Ferramenta de Composição</title>
        <mediaobject
><imageobject>
              <imagedata format="PNG" fileref="compound.png"/>
        </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject
><imagedata format="PNG" fileref="compoundtool.png"/>
        </imageobject
></inlinemediaobject
></para>
        
        <para
>A ferramenta de composição não representa nenhumas expressões regulares. É usada para agrupar outras sub-componentes em conjunto dentro de uma caixa, a qual poderá facilmente ser fechada, restringindo-se apenas ao seu título. Isto poderá ser visto na parte direita do resultado do ecrã acima.</para>
      </simplesect>





      <simplesect id="positiontool"
><title
>Ferramentas do Início/Fim da Linha</title>
        <mediaobject
><imageobject>
            <imagedata format="PNG" fileref="begline.png"/>
        </imageobject
></mediaobject>
          <mediaobject
><imageobject>
              <imagedata format="PNG" fileref="endline.png"/>
        </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject
><imagedata format="PNG" fileref="linestartendtool.png"/>
        </imageobject
></inlinemediaobject
></para>

        <para
>As ferramentas do início e do fim de linha correspondem, respectivamente ao início da linha ou ao seu fim, como seria de esperar. A expressão regular no resultado do ecrã acima corresponde deste modo às linhas que só tenham espaços.</para>
        
        <para
>Veja a descrição sobre as <link linkend="positionregexp"
>expressões regulares de posição</link
>.</para>
      </simplesect>





      <simplesect
><title
>Ferramentas de (Não-)Limite das Palavras</title>
      <mediaobject
><imageobject>
            <imagedata format="PNG" fileref="wordboundary.png"/>
            </imageobject
></mediaobject>
          <mediaobject
><imageobject
><imagedata format="PNG" fileref="nonwordboundary.png"/>
        </imageobject
></mediaobject>
        <para
><inlinemediaobject
><imageobject
><imagedata format="PNG" fileref="boundarytools.png"/>
        </imageobject
></inlinemediaobject
></para>

        <para
>As ferramentas dos limites fazem a sua correspondência com os limites das palavras ou das outras sequências que não representem palavras, respectivamente. A expressão regular no resultado do ecrã acima corresponderá às palavras que comecem por <literal
>the</literal
>. A palavra <literal
>the</literal
> em si, todavia, não fará correspondência.</para>

        <para
>Veja a descrição sobre as <link linkend="boundaryregexp"
>expressões regulares dos limites</link
>.</para>
      </simplesect>





      <simplesect id="lookaheadtools"
><title
>Ferramentas de Leitura Antecipada Positiva/Negativa</title>
	  <mediaobject
><imageobject
> <imagedata format="PNG" fileref="poslookahead.png"/>
        </imageobject
></mediaobject>
          <mediaobject
><imageobject
> <imagedata format="PNG" fileref="neglookahead.png"/>
        </imageobject
></mediaobject>

        <para
><inlinemediaobject
><imageobject
> <imagedata format="PNG" fileref="lookaheadtools.png"/>
        </imageobject
></inlinemediaobject
></para>

        <para
>As ferramentas de leitura antecipada tanto poderão corresponder a expressões positivas ou negativas. A correspondência não faz, contudo, parte da correspondência total.</para>

        <para
>Nota: Só lhe é permitido colocar leituras antecipadas no fim das expressões regulares. O Editor de Expressões Regulares não obriga a isto.</para>

        <para
>Veja a descrição sobre as <link linkend="lookaheadregexp"
>expressões regulares com leitura antecipada</link
>.</para>
      </simplesect>
    </sect1>

  <!-- ====================================================================== -->
  <!--                  User Defined Regular Expressions                      -->
  <!-- ====================================================================== -->
    <sect1 id="userdefinedregexps">
      <title
>Expressões Regulares Definidas pelo Utilizador</title>
      <para
>À esquerda a área de edição existe uma lista que contém as expressões regulares definidas pelo utilizador. Algumas das expressões regulares vêm incluídas na sua instalação do KDE, enquanto que outras poderão ser gravadas por si.</para
> 

      <para
>Estas expressões regulares servem dois propósitos (<link linkend="screenorganization"
>ver uma descrição detalhada</link
>), nomeadamente (1) oferecer ao utilizador um conjunto de peças de construção e (2) tornar as expressões regulares comuns mais bonitas.</para>

      <para
>Você poderá gravar as suas próprias expressões regulares ao carregar com o botão direito do rato na área de edição e ao escolher a opção <literal
>Gravar a Expressão Regular</literal
>.</para>

      <para
>Se a expressão regular que gravar estiver dentro de um <link linkend="compoundtool"
>bloco de composição</link
>, então a expressão regular irá ajudar a tornar as expressões regulares subsequentes mais bonitas.</para>

      <para
>A expressão regular definida pelo utilizador pode ser removida ou ver o seu nome alterado ao carregar com o botão direito na lista, mais precisamente no cimo da expressão regular em questão.</para>
    </sect1>
  </chapter>

  <!-- ====================================================================== -->
  <!--                  Reporting a bug and Suggesting Features               -->
  <!-- ====================================================================== -->
  <chapter id="bugreport">
    <title
>Comunicar erros e sugerir funcionalidades</title>
    <para
>Os erros e funcionalidades comunicados são introduzidos no <ulink url="http://bugs.kde.org/"
>Sistema de Registo de Erros do KDE</ulink
>. <emphasis role="strong"
>Antes</emphasis
> de comunicar um erro ou sugerir uma funcionalidade, verifique primeiro se esta não foi já <ulink url="http://bugs.kde.org/simple_search.cgi?id=kregexpeditor"
>comunicada/sugerida.</ulink
></para>
  </chapter>

  <!-- ====================================================================== -->
  <!--                                 FAQ                                    -->
  <!-- ====================================================================== -->
  <chapter id="faq">
    <title
>Perguntas Mais Frequentes</title>
    <sect1 id="question1">
      <title
>O editor de expressões regulares suporta referências anteriores?</title>
      <para
>Não, de momento isto não é suportado. Está planeado para a próxima versão.</para>
    </sect1>

    <sect1 id="question2">
      <title
>O editor de expressões regulares suporta a apresentação das ocorrências?</title>
      <para
>Não, mas espera-se que isto esteja disponível na próxima versão.</para>
    </sect1>

    <sect1 id="question3">
      <title
>Eu sou o autor de um programa do KDE, como é que posso usar este item na minha aplicação?</title>
      <para
>Veja na <ulink url="http://developer.kde.org/documentation/library/cvs-api/classref/interfaces/KRegExpEditorInterface.html"
>documentação da classe KRegExpEditorInterface</ulink
>.</para>
    </sect1>

    <sect1 id="question4">
      <title
>Não consigo encontrar o botão <emphasis
>Editar a Expressão Regular</emphasis
> numa instalação do KDE 3 ou no 'konqueror', por exemplo. Porquê?</title>
      <para
>O item de expressões regulares está localizado no pacote 'KDE-utils'. Se você não tiver este pacote instalado, então os botões para <emphasis
>editar expressões regulares</emphasis
> não irão aparecer nos programas.</para>
    </sect1>
  </chapter>

  <!-- ====================================================================== -->
  <!--                           Credits and Licenses                         -->
  <!-- ====================================================================== -->
  <chapter id="credits-and-license">
    <title
>Créditos e Licenças</title>

    <para
>Documentação copyright 2001, Jesper K. Pedersen <email
>blackie@kde.org</email
> </para>
&underGPL; &underFDL; </chapter>


</book>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-namecase-general:t
sgml-general-insert-case:lower
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:2
sgml-indent-data:t
sgml-parent-document:nil
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
-->
