José
Pires

    zepires@gmail.com

Tradução

# Trabalhar com o Realce de Sintaxe

## Introdução

O Realce de Sintaxe é o que faz o editor mostrar automaticamente o texto em diferentes estilos/cores, dependendo da função do texto em relação ao propósito do ficheiro. No código-fonte de um programa, por exemplo, as instruções de controlo podem ser representadas a negrito, enquanto os tipos de dados e os comentários têm cores diferentes do resto do texto. Isto aumenta em larga medida a legibilidade do texto, e por isso ajuda o autor a ser mais eficiente e produtivo.

Uma função de Perl, representada com realce de sintaxe.

Uma função de Perl, representada com realce de sintaxe.

A mesma função de Perl, sem realce de sintaxe.

A mesma função de Perl, sem realce de sintaxe.

Dos dois exemplos, qual é o mais fácil de ler?

O &kappname; vem com um sistema flexível, configurável e capaz de fazer realce de sintaxe; a distribuição normal oferece definições para um conjunto vasto de linguagens de programação, de manipulação e de 'scripting', bem como para outros formatos de texto. Para além disso, pode criar as suas próprias definições em ficheiros &XML; simples.

O &kappname; irá detectar automaticamente as regras de sintaxe correctas quando abrir um ficheiro, baseando-se no tipo &MIME; do ficheiro, pela sua extensão, ou se não tiver nenhuma, pelo seu conteúdo. Se a escolha for errada, pode definir manualmente a sintaxe a usar no menu Documentos Realce.

Os estilos e cores usados por cada definição de realce de sintaxe podem ser configurados usando a página de Estilos de Texto do Realce da Janela de Configuração; por outro lado, os tipos &MIME; para os quais deve ser usada, podem ser configurados usando a página de Modos & Tipos de Ficheiros.

O realce de sintaxe existe para melhorar a legibilidade do texto correcto, mas não pode esperar que ela valide o seu texto. A marcação do texto para a sintaxe é complicada, dependendo do formato que está a usar e, em muitos dos casos, os autores das regras de sintaxe sentir-se-ão orgulhosos se 98% do texto for correctamente apresentado, ainda que na maior parte das vezes precisa de um estilo raro para ver os 2% incorrectos.

Pode obter as definições de sintaxe adicionais ou actualizadas na página Web do &kappname; se carregar no botão Obter Ficheiros de Realce... na página de Modos & Tipos de Ficheiros da Janela de Configuração.

## O Sistema de Realce de Sintaxe do &kappname;

Esta secção irá discutir o realce de sintaxe do &kappname; com mais detalhe. É para si, se quiser saber acerca dele ou se quiser criar ou alterar as definições de sintaxe.

### Como Funciona

Sempre que o utilizador abrir um ficheiro, uma das primeiras coisas que o editor do &kappname; faz é detectar qual a definição de sintaxe a usar para o ficheiro. Enquanto vai lendo o texto do ficheiro, e enquanto você vai escrevendo nele, o sistema de realce de sintaxe irá analisar o texto usando as regras definidas pela definição da sintaxe e marcá-la onde os diferentes contextos e estilos começam e acabam.

Quando escrever no documento, o novo texto é analisado e marcado na altura, por isso, se apagar um carácter que está marcado como o início ou o fim de um contexto, o estilo do texto circundante muda de acordo com esse facto.

As definições de sintaxe usadas pelo sistema de realce de sintaxe do &kappname; são ficheiros &XML; que contêm

- As regras para detectar o papel do texto, organizado em blocos de contextos

- Listas de palavras-chave

- Definições de Itens de Estilo

Ao analisar o texto, as regras de detecção são avaliadas na ordem em que são definidas, e se o início do texto actual corresponder a uma regra, o contexto relacionado será usado. O ponto inicial do texto é movido para o ponto final a partir do qual essa regra correspondeu, dando-se início a mais um ciclo das regras, o qual dá início no conjunto de contextos definido pela regra correspondente.

### Regras

As regras de detecção são o 'coração' do sistema de detecção de sintaxe. Uma regra é uma cadeia de caracteres, um carácter ou uma expressão regular com a qual se faz a correspondência do texto a analisar. Contém informações sobre o estilo a usar para a parte correspondente do texto. Pode mudar do contexto actual do sistema para um outro contexto explícito ou para o contexto anterior usado pelo texto.

As regras são organizadas em grupos de contextos. Um grupo de contextos é usado para os conceitos principais do formato como, por exemplo, as cadeias de caracteres entre aspas ou os blocos de comentários no código-fonte do programa. Isto garante que o sistema de realce de sintaxe não precisa de circular por todas as regras quando não é necessário, e que algumas sequências de caracteres no texto podem ser tratadas de modo diferente, dependendo do contexto actual.

Os contextos poderão ser gerados dinamicamente, para permitir a utilização de dados específicos das instâncias nas regras.

### Estilos de Contexto e Palavras-Chave

Em algumas linguagens de programação, os números inteiros são tratados de forma diferente dos números de vírgula flutuante pelo compilador (o programa que converte o código-fonte num executável binário), assim como podem existir caracteres com um significado especial dentro de uma cadeia de caracteres entre aspas. Em ambos os casos, faz sentido mostrá-los de forma diferente dos seus vizinhos, de modo a que sejam fáceis de identificar enquanto o utilizador lê o texto. Por isso, mesmo que não representem contextos especiais, podem ser vistos como tal pelo sistema de realce de sintaxe, de modo que possam ser marcados para ser desenhados de diferente forma.

Uma definição de sintaxe pode conter tantos estilos quantos necessários para cobrir os conceitos do formato no qual é usado.

Em vários formatos, existem listas de palavras que representam um conceito específico. Como exemplo nas linguagens de programação, as instruções de controlo são um conceito, os tipos de dados são outro e as funções intrínsecas à linguagem são um terceiro conceito. O Sistema de Realce de Sintaxe do &kappname; pode usar essas listas para detectar e marcar as palavras no texto de modo a realçar os conceitos dos formatos de texto.

### Estilos por Omissão

Se abrir um ficheiro de código em C++, um ficheiro de &Java; e um documento em HTML no &kappname;, irá ver que, ainda que os formatos sejam diferentes e, por isso, sejam seleccionadas palavras diferentes para um tratamento especial, as cores usadas são as mesmas. Isto deve-se ao facto do &kappname; ter uma lista predefinida de Estilos Predefinidos, os quais são empregues pelas definições de sintaxe individuais.

Isto facilita o reconhecimento de conceitos similares nos diferentes formatos de texto. Por exemplo, os comentários estão presentes em quase todas as linguagens de programação, 'scripting' ou de marcação, e quando são representados com o mesmo estilo em todas as linguagens, você não terá de parar e pensar para os identificar no texto.

Todos os estilos de uma definição de sintaxe usam um dos estilos por omissão. Algumas definições de sintaxe usam mais estilos para além dos predefinidos, por isso se usar um formato frequentemente, pode ser útil abrir a janela de configuração para ver se alguns conceitos estão a usar o mesmo estilo. Por exemplo, só existe um estilo por omissão para as cadeias de caracteres, mas como a linguagem de programação Perl lida com dois tipos de cadeias de caracteres, pode melhorar o realce se configurar esses dois tipos de uma forma ligeiramente diferente. Todos os estilos predefinidos disponíveis serão explicados mais tarde.

## O Formato &XML; da Definição de Realce

### Introdução

Esta secção é uma introdução ao formato &XML; da Definição de Realce. Irá descrever as componentes principais, bem como o seu significado e utilização, indo em mais detalhes com as regras de detecção.

A definição formal, mais conhecida por DTD, é guardada no ficheiro `language.dtd`, o qual deve estar instalado no seu sistema na pasta `$`KDEDIR`/share/apps/katepart/syntax`.

#### Componentes principais das Definições de Realce do &kappname;

Um ficheiro de realce contém um cabeçalho que define a versão do XML e o tipo de documento:

      <?xml version="1.0" encoding="UTF-8"?>
      <!DOCTYPE language SYSTEM "language.dtd">

A raiz do ficheiro de definição é o elemento `language`. Os atributos disponíveis são:

  Atributos necessários:

  O `name` define o nome da linguagem. Ele aparece nos menus e nas janelas respectivas.

  O `section` indica a categoria.

  O `extensions` define as extensões dos ficheiros, como por exemplo "*.cpp;*.h"

  Atributos opcionais:

  O `mimetype` associa os ficheiros com base no Tipo &MIME;.

  O `version` indica a versão actual do ficheiro de definição.

  O `kateversion` indica a última versão suportada pelo &kappname;.

  O `casesensitive` define se as palavras-chave fazem distinção entre maiúsculas e minúsculas.

  O `priority` é necessário se outro ficheiro de definições de realce usar as mesmas extensões. Ganhará o que tiver maior prioridade.

  O `author` contém o nome do autor e o seu endereço de e-mail.

  O `license` contém a licença, que é normalmente a LGPL, a Artistic, a GPL, entre outras.

  O `hidden` define se o nome deverá aparecer nos menus do &kappname;.

  Como tal, a próxima linha parece-se com o seguinte:

      <language name="C++" version="1.00" kateversion="2.4" section="Sources" extensions="*.cpp;*.h" />

A seguir vem o elemento `highlighting`, que contém o elemento opcional `list` e os elementos obrigatórios `contexts` e `itemDatas`.

  O elemento `list` contém uma lista de palavras-chave. Neste caso, as palavras-chave são a class e a const. Poderá adicionar tantas listas quanto desejar.

  O elemento `contexts` contém todos os contextos. O primeiro contexto é, por omissão, o início do realce. Existem duas regras no contexto Normal Text (Texto Normal), que correspondem à lista de palavras-chave com o nome um_nome e uma regra que detecta aspas e muda o contexto para string (cadeia de caracteres). Para aprender mais sobre as regras, leia o próximo capítulo.

  A terceira parte é o elemento `itemDatas`. Contém todas as cores e estilos de letra necessários pelos contextos e regras. Neste exemplo, são usados o `itemData` de Normal Text (Texto Normal), String (Cadeia de Caracteres) e Keyword (Palavra-Chave).

      <highlighting>
          <list name="um_nome">
            <item> class </item>
            <item> const </item>
          </list>
          <contexts>
            <context attribute="Normal Text" lineEndContext="#pop" name="Normal Text" >
              <keyword attribute="Keyword" context="#stay" String="somename" />
              <DetectChar attribute="String" context="string" char="&quot;" />
            </context>
            <context attribute="String" lineEndContext="#stay" name="string" >
              <DetectChar attribute="String" context="#pop" char="&quot;" />
            </context>
          </contexts>
          <itemDatas>
            <itemData name="Normal Text" defStyleNum="dsNormal" />
            <itemData name="Keyword" defStyleNum="dsKeyword" />
            <itemData name="String" defStyleNum="dsString" />
          </itemDatas>
        </highlighting>

A última parte de uma definição de realce é a secção opcional `general`. Poderá conter informações acerca das palavras-chave, expansão/recolhimento de código, comentários e indentação.

  A secção `comment` define com que texto é introduzido um comentário para uma única linha. Poderá também definir comentários multi-linha, usando o multiLine com o atributo adicional end. Isto aplica-se se o utilizador carregar no atalho correspondente para comentar/descomentar.

  A secção `keywords` define se as listas de palavras-chave fazem distinção entre maiúsculas e minúsculas ou não. Os outros atributos serão explicados mais tarde.

      <general>
          <comments>
            <comment name="singleLine" start="#"/>
          </comments>
          <keywords casesensitive="1"/>
        </general>
      </language>

### As Secções em Detalhe

Esta parte irá descrever todos os atributos disponíveis para o 'contexts', o 'itemDatas', o 'keywords', o 'comments', a expansão de código e a indentação.

O elemento `context` pertence ao grupo `contexts`. Um contexto, por si só, define as regras específicas do contexto, como o que deve acontecer se o sistema de realce chegar ao fim de uma linha. Os atributos disponíveis são:

  `name` o nome do contexto. As regras irão usar este nome para indicar o contexto para onde mudar, se a regra corresponder.

  O `lineEndContext` define o contexto para onde o sistema de realce salta, se atingir o fim de uma linha. Poderá ser o nome de outro contexto, o `#stay` para não mudar de contexto (&eg;, não fazer nada) ou o `#pop` que fará com que saia deste contexto. É possível usar, por exemplo, `#pop#pop#pop` para sair de dentro de três contextos.

  O `lineBeginContext` define o contexto, se for encontrado o início de uma linha. Por omissão: #stay.

  O `fallthrough` define se o sistema de realce salta para o contexto indicado em 'fallthroughContext' se não corresponder nenhuma regra. Por omissão: false.

  O `fallthroughContext` define o próximo contexto, se nenhuma regra corresponder.

  O `dynamic`, se for true (verdadeiro), fará com que o contexto recorde os textos/sequências de substituição gravados pelas regras dinâmicas. Isto é necessário, por exemplo, para os documentos do HERE. Por omissão: false.

O elemento `itemData` está no grupo `itemDatas`. Define o estilo e as cores do tipo de letra. Como tal, é possível definir os seus próprios estilos e cores, contudo recomenda-se que use os estilos predefinidos, para que o utilizador veja sempre as mesmas cores que são usadas nas várias linguagens. Todavia, existem casos em que não existe outra forma e, como tal, é necessário mudar os atributos de cores e tipos de letra. Os atributos 'name' e 'defStyleNum' são obrigatórios, enquanto os outros são opcionais. Os atributos disponíveis são:

  O `name` define o nome do 'itemData'. Os contextos e regras irão usar este nome no seu atributo attribute, para referenciar um 'itemData'.

  O `defStyleNum` define qual o estilo predefinido a usar. Os estilos predefinidos disponíveis são explicados mais tarde em detalhe.

  O `color` define uma cor. Os formatos válidos são o '#rrggbb' ou '#rgb'.

  O `selColor` define a cor da selecção.

  O `italic`, se for true (verdadeiro), irá colocar o texto em itálico.

  O `bold`, se for true (verdadeiro), irá colocar o texto em negrito.

  O `underline`, se for true (verdadeiro), irá colocar o texto sublinhado.

  O `strikeout`, se for true (verdadeiro), irá colocar o texto traçado.

  O `spellChecking`, se for true (verdadeiro), irá activar a verificação ortográfica; caso contrário, esta será ignorada.

O elemento `keywords`, no grupo `general`, define as propriedades das palavras-chave. Os atributos disponíveis são:

  O `casesensitive` poderá ser true (verdadeiro) ou false (falso). Se for true, todas as palavras-chave farão distinção entre maiúsculas e minúsculas

  O `weakDeliminator` é uma lista de caracteres que não irão actuar como separadores de palavras. Por exemplo, o ponto `'.'` é um separador de palavras. Assuma que uma palavra-chave num `list` contém um ponto; nesse caso, só irá corresponder se indicar que o ponto é um delimitador fraco.

  O `additionalDeliminator` define os delimitadores ou separadores adicionais.

  O `wordWrapDeliminator` define os caracteres após os quais poderá ocorrer uma mudança de linha.

  Os delimitadores predefinidos e de mudança de linha são os caracteres `.():!+,-<=>%&*/;?[]^{|}~\`, o espaço (`' '`) e a tabulação (`'\t'`).

O elemento `comment`, no grupo `comments`, define as propriedades dos comentários que são usadas nas opções Ferramentas Comentar e Ferramentas Descomentar. Os atributos disponíveis são:

  O `name` tanto poderá ser singleLine como multiLine. Se escolher o multiLine, serão necessários os atributos end e region.

  O `start` define o texto usado para iniciar um comentário. No C++, este será o "/*".

  O `end` define o texto usado para fechar um comentário. No C++, será o "*/".

  O `region` deverá ser o nome do comentário multi-linhas que poderá expandir ou recolher. Assuma que tem o beginRegion="Comment" ... endRegion="Comment" nas suas regras; nesse caso, deverá usar o region="Comment". Desta forma, a remoção de comentários funciona, mesmo que não tenha seleccionado todo o texto do comentário multi-linhas. O cursor só necessita de estar dentro deste comentário.

O elemento `folding`, no grupo `general`, define as propriedades de dobragem/desdobramento do código. Os atributos disponíveis são:

  O `indentationsensitive`, se for true, aplicará os marcadores de dobragem de código com base na indentação, como acontece na linguagem de programação Python. Normalmente não terá de definir isto, dado que é por omissão false.

O elemento `indentation`, no grupo `general`, define qual o sistema de indentação a usar; contudo, recomenda-se que omita este elemento, dado que o sistema de indentação será normalmente definido a partir de um Tipo de Ficheiro ou através da adição da linha de modo no ficheiro de texto. Se indicar um sistema de indentação, todavia, irá obrigar o utilizador a usar um sistema de indentação específico, o que poderá não ser do agrado dele. Os atributos disponíveis são:

  O `mode` é o nome do sistema de indentação. Os sistemas disponíveis de momento são: normal, cstyle, haskell, lilypond, lisp, python, ruby e xml.

### Estilos Predefinidos Disponíveis

Os estilos por omissão já foram explicados, em resumo: Os estilos predefinidos são os estilos de cores e tipos de letra predefinidos.

Como tal, só aparece aqui a lista de estilos predefinidos disponíveis:

  `dsNormal`, usado para o texto normal.

  `dsKeyword`, usado nas palavras-chave.

  `dsDataType`, usado nos tipos de dados.

  `dsDecVal`, usado nos valores decimais.

  `dsBaseN`, usados nos valores com uma base diferente de 10.

  `dsFloat`, usado nos valores de vírgula flutuante.

  `dsChar`, usado para um único carácter.

  `dsString`, usado para conjuntos ou cadeias de caracteres.

  `dsComment`, usado nos comentários.

  `dsOthers`, usado para outras coisas.

  `dsAlert`, usado nas mensagens de aviso.

  `dsFunction`, usado nas chamadas a funções.

  `dsRegionMarker`, usado nos marcadores de regiões.

  `dsError`, usado para realçar erros e sintaxes inválidas.

## Regras de Detecção do Realce

Esta secção descreve as regras de detecção da sintaxe.

Cada regra pode corresponder a zero ou mais caracteres no início do texto que é testado. Se a regra corresponder, é atribuído o estilo ou atributo definido pela regra aos caracteres correspondentes; uma regra poderá perguntar se o contexto actual será alterado.

Uma regra parece-se com o seguinte:

    <NomeRegra attribute="(identificador)" context="(identifier|order)" [atributos específicos da regra] />

O attribute identifica o estilo a usar para os caracteres correspondentes pelo nome ou índice; o context identifica, como será de esperar, o contexto a usar a partir daqui.

O context pode ser identificado por:

- Um identificador, o qual é o nome do outro contexto.

- Uma ordem que indica ao motor para permanecer no contexto actual (`#stay`) ou para voltar a um contexto anterior usado no texto (`#pop`).

  Para recuar mais vezes, a palavra '#pop' pode ser repetida: `#pop#pop#pop`

Algumas regras podem ter regras-filhas, as quais podem ser avaliadas se e só se a regra-mãe foi verificada. O texto inteiro verificado terá o atributo definido pela regra-mãe. Uma regra com regras-filhas será algo do género:

    <NomeRegra (atributos)>
      <NomeRegraFilho (atributos) />
      ...
    </NomeRegra>

Os atributos específicos da regra variam e estão descritos nas seguintes secções.

### Atributos comuns

Todas as regras têm os seguintes atributos em comum e estão disponíveis sempre que os `(atributos comuns)` aparecerem. O attribute e o context são atributos obrigatórios, enquanto os outros são opcionais.

- atributo: Um atributo mapeia-se num itemData definido.

- context: Indica o contexto para onde muda o sistema de realce, se a regra corresponder.

- beginRegion: Inicia um bloco de dobragem de código. Por omissão: não definido.

- endRegion: Fecha uma região de dobragem de código. Por omissão: não definido.

- lookAhead: Se for true (verdadeiro), o sistema de realce não irá processar o tamanho da correspondência. Por omissão: false.

- firstNonSpace: Corresponder apenas se o texto for o primeiro não-espaço em branco da linha. Por omissão: false.

- column: Corresponder apenas se a coluna corresponder. Por omissão: não definido.

### Regras dinâmicas

Algumas regras permitem o atributo opcional `dynamic`, do tipo booleano, cujo valor por omissão é false. Se o 'dynamic' for true, uma regra poderá usar sequências de substituição que representam o texto correspondente a uma expressão regular que mudou para o contexto actua, nos seus atributos `string` ou `char`. Num `string`, o texto de substituição %N (em que o N é um número) será substituído pela captura correspondente a N na expressão regular de chamada. Num `char`, a sequência de substituição deverá ser um número N que será substituído pelo primeiro carácter da captura N da expressão regular de chamada. Sempre que uma regra permitir este atributo, irá conter um (dinâmico).

- dynamic: poderá ser (true|false).

### As Regras em Detalhe

DetectChar

  Detecta um único carácter específico. É usado vulgarmente para encontrar, por exemplo, o fim das cadeias de caracteres entre aspas.

      <DetectChar char="(carácter)" (atributos comuns) (dinâmico) />

  O atributo `char` define o carácter a encontrar.

Detect2Chars

  Detecta dois caracteres específicos numa ordem definida.

      <Detect2Chars char="(carácter)" char1="(carácter)" (atributos comuns) (dinâmico) />

  O atributo `char` define o primeiro carácter a encontrar, enquanto `char1` define o segundo.

AnyChar

  Detecta um carácter de um conjunto de caracteres especificados.

      <AnyChar String="(texto)" (atributos comuns) />

  O atributo `String` define o conjunto de caracteres.

StringDetect

  Detecta um texto exacto.

      <StringDetect String="(string)" [insensitive="TRUE|FALSE;"] (atributos comuns) (dinâmico) />

  O atributo `String` define a sequência a encontrar. O atributo `insensitive` é por omissão `false` e é passado à função de comparação de cadeias de caracteres. Se o valor for `true` a comparação não faz distinção entre maiúsculas e minúsculas.

WordDetect

  Detecta um texto exacto, mas obriga adicionalmente a que esteja rodeado por limites de palavras, como um ponto `'.'` ou um espaço em branco no início e no fim da palavra. Pense em `\b<texto>\b` em termos de uma expressão regular, só que é mais rápido que a regra `Exp Reg`.

      <WordDetect String="(string)" [insensitive="true|false;"] (atributos comuns) (dinâmico) />

  O atributo `String` define a sequência a encontrar. O atributo `insensitive` é por omissão `false` e é passado à função de comparação de cadeias de caracteres. Se o valor for `true` a comparação não faz distinção entre maiúsculas e minúsculas.

  Desde: Kate 3.5 (KDE 4.5)

RegExpr

  Corresponde a uma expressão regular.

      <RegExpr String="(texto)" [insensitive="TRUE|FALSE;"] [minimal="TRUE|FALSE"] (atributos comuns) (dinâmico) />

  O atributo `String` define a expressão regular.

  O `insensitive` é, por omissão, `false` e é passado ao motor de expressões regulares.

  O `minimal` é, por omissão, `false` e é passado ao motor de expressões regulares.

  Como as regras se aplicam ao início do texto actual, uma expressão regular que comece por um acento circunflexo (`^`) indica que a regra só deve ser verificada se for no início de uma linha.

  Veja as Expressões Regulares para mais informações sobre elas.

keyword

  Detecta uma palavra-chave a partir de uma lista específica.

      <keyword String="(nome da lista)" (atributos comuns) />

  O atributo `String` identifica a lista de palavras-chave pelo seu nome. Deve existir uma lista com esse nome.

Int

  Detecta um número inteiro.

      <Int (atributos comuns) (dinâmico) />

  Esta regra não tem atributos específicos. As regras-filho são tipicamente usadas para detectar as combinações de `L` e `U` depois do número, o que indica o tipo inteiro no código do programa. De facto, todas as regras são permitidas como regras-filhas, contudo, o DTD só permite a regra-filha `StringDetect`.

  O exemplo seguinte faz correspondência com os números inteiros, seguidos do carácter 'L'.

      <Int attribute="Decimal" context="#stay" >
        <StringDetect attribute="Decimal" context="#stay" String="L" insensitive="true"/>
      </Int>

Float

  Detecta um número de vírgula flutuante.

      <Float (atributos comuns) />

  Esta regra não tem atributos específicos. O `AnyChar` é permitido como regra-filha e é tipicamente usada para detectar combinações; veja a regra `Int` para mais referências.

HlCOct

  Detecta uma representação de um número octal.

      <HlCOct (atributos comuns) />

  Esta regra não tem atributos específicos.

HlCHex

  Detecta uma representação de um número em hexadecimal.

      <HlCHex (atributos comuns) />

  Esta regra não tem atributos específicos.

HlCStringChar

  Detecta um carácter 'escapado'.

      <HlCStringChar (atributos comuns) />

  Esta regra não tem atributos específicos.

  Corresponde a representações literais dos caracteres usados normalmente no código do programa como, por exemplo, o `\n` (nova linha) ou o `\t` (TAB).

  Os seguintes caracteres irão corresponder se estiverem a seguir a uma barra invertida (`\`): `abefnrtv"'?\`. Para além disso, os números escapados em hexadecimal como, por exemplo, o `\xff` e os números octais escapados, como o `\033`, irão corresponder.

HlCChar

  Detecta um carácter do C.

      <HlCChar (atributos comuns) />

  Esta regra não tem atributos específicos.

  Corresponde aos caracteres em C colocados dentro de plicas (Exemplo: `'c'`). Como tal, dentro das plicas poderá estar um único carácter ou um carácter de escape. Veja o 'HlCStringChar' para ver as sequências de caracteres de escape correspondentes.

RangeDetect

  Detecta uma cadeia de caracteres com os caracteres de início e fim definidos.

      <RangeDetect char="(carácter)"  char1="(carácter)" (atributos comuns) />

  O `char` define o carácter de início e o `char1` o carácter que termina o intervalo.

  Útil para detectar, por exemplo, pequenas cadeias de caracteres entre aspas e semelhantes, mas repare que, dado que o motor de realce de sintaxe funciona com uma linha de cada vez, isto não irá encontrar as cadeias de caracteres que se prolonguem por mais do que uma linha.

LineContinue

  Corresponde uma barra invertida (`'\'`) ao fim de uma linha.

      <LineContinue (atributos comuns) />

  Esta regra não tem atributos específicos.

  Esta regra é útil para mudar de contexto no fim da linha, se o último carácter for uma barra invertida (`'\'`). Isto é necessário, por exemplo no C/C++, para continuar as macros ou cadeias de caracteres.

IncludeRules

  Inclui as regras de outro contexto ou linguagem/ficheiro.

      <IncludeRules context="ligacao_contexto" [includeAttrib="true|false"] />

  O atributo `context` define o contexto a incluir.

  Se for texto simples, inclui todas as regras definidas no contexto actual, como por exemplo:

      <IncludeRules context="outroContexto" />

  Se o texto começar por `##`, o sistema de realce irá procurar outra definição de linguagem com o nome indicado, como por exemplo:

      <IncludeRules context="##C++" />

  Se o atributo `includeAttrib` for true, muda o atributo de destino para o da origem. Isto é necessário para fazer, por exemplo, funcionar os comentários, se o texto correspondente ao contexto incluído for de um realce diferente do contexto-anfitrião.

DetectSpaces

  Detecta espaços em branco.

      <DetectSpaces (atributos comuns) />

  Esta regra não tem atributos específicos.

  Use esta regra se souber que poderão existir vários espaços em branco à frente como, por exemplo, no início das linhas indentadas. Esta regra irá ignorar todos os espaços em branco, em vez de testar várias regras e ignorar uma de cada vez, devido a uma falta de correspondência.

DetectIdentifier

  Detecta os textos dos identificadores (como acontece na expressão regular: [a-zA-Z_][a-zA-Z0-9_]*).

      <DetectIdentifier (atributos comuns) />

  Esta regra não tem atributos específicos.

  Use esta regra para ignorar uma sequência de caracteres de palavras de uma vez, em vez de testar com várias regras e ignorar uma de cada vez, por falta de correspondência.

### Dicas & Truques

Logo que tenha compreendido como funciona a mudança de contexto, será fácil de criar definições de realce. Ainda que deva verificar com cuidado a regra que escolhe, dependendo da situação, as expressões regulares são muito poderosas, só que são lentas em comparação com as outras regras. Como tal, poderá considerar as seguintes dicas.

- Se só corresponder com 2 caracteres, use o `Detect2Chars` em vez do `StringDetect`. O mesmo aplica-se ao `DetectChar`.

- As expressões regulares são fáceis de usar mas, normalmente, existe outra forma muito mais rápida de obter o mesmo resultado. Assuma que só deseja corresponder com o carácter `'#'` se for o primeiro carácter da linha. Uma solução baseada em expressões regulares seria semelhante à seguinte:

      <RegExpr attribute="Macro" context="macro" String="^\s*#" />

  Poderá obter o mesmo se usar:

      <DetectChar attribute="Macro" context="macro" char="#" firstNonSpace="true" />

  Se quiser corresponder à expressão regular `'^#'`, poderá usar à mesma o `DetectChar` com o atributo `column="0"`. O atributo `column` conta com base no número de caracteres; como tal, uma tabulação conta à mesma como se fosse apenas um carácter.

- Poderá mudar de contextos sem processar os caracteres. Assuma que deseja mudar de contexto quando encontrar o texto `*/`, mas necessita de processar essa sequência no próximo contexto. A regra abaixo irá corresponder e o atributo `lookAhead` fará com que o sistema de realce mantenha o texto correspondente no próximo contexto.

      <Detect2Chars attribute="Comment" context="#pop" char="*" char1="/" lookAhead="true" />

- Use o `DetectSpaces` se souber que irão ocorrer vários espaços em branco.

- Use o `DetectIdentifier` em vez da expressão regular `'[a-zA-Z_]\w*'`.

- Use os estilos predefinidos sempre que puder. Desta forma, o utilizador irá encontrar um ambiente familiar.

- Procure noutros ficheiros XML para ver como as outras pessoas implementam as regras mais complicadas.

- Poderá validar todos os ficheiros XML se usar o comando `xmllint --dtdvalid language.dtd aMinhaSintaxe.xml`.

- Se repetir algumas expressões regulares complexas com frequência, poderá usar as ENTIDADES. Por exemplo:

      <?xml version="1.0" encoding="UTF-8"?>
      <!DOCTYPE language SYSTEM "language.dtd"
      [
              <!ENTITY referencia    "[A-Za-z_:][\w.:_-]*">
      ]>

  Agora, poderá usar o &referencia; em vez da expressão regular.