# Lavorare con l'evidenziazione della sintassi

## Panoramica

L'evidenziazione della sintassi è ciò che rende l'editor capace di mostrare il testo in diversi stili e colori, a seconda della funzione delle stringhe per il tipo di file in fase di modifica. Nei sorgenti dei programmi, ad esempio, le istruzioni di controllo potrebbero essere rese in grassetto, mentre i tipi di dato ed i commenti potrebbero essere colorati diversamente dal resto del testo. Ciò migliora molto la leggibilità del testo, e quindi aiuta l'autore ad essere più efficiente e produttivo.

Una funzione Perl, mostrata con l'evidenziazione della sintassi.

Una funzione Perl, mostrata con l'evidenziazione della sintassi.

La stessa funzione Perl, senza l'evidenziazione.

La stessa funzione Perl, senza l'evidenziazione.

Dei due esempi, qual è la più facile da leggere?

&kappname; ha un sistema flessibile, configurabile e capace per eseguire l'evidenziazione della sintassi, e la distribuzione standard fornisce le definizioni per un'ampia gamma di linguaggi di programmazione, script, a marcatori e altri formati di file testuali. In più, puoi fornire le tue definizioni in semplici file &XML;.

&kappname; riconosce automaticamente le regole di sintassi appropriate quando apre un file, in base al suo tipo &MIME;, determinato dall'estensione, o se non ne ha, dal contenuto. Se facesse una scelta sbagliata, puoi indicare a mano la sintassi da usare dal menu Strumenti Evidenziazione.

Gli stile e colori usati da ciascuna definizione di evidenziazione della sintassi possono essere configurati usando la linguetta Stili di evidenziazione testo della finestra di configurazione, mentre i tipi &MIME; per cui va usato sono gestiti dalla linguetta Modi & tipi di file.

L'evidenziazione della sintassi è fatta per migliorare la leggibilità di testo corretto, ma non puoi affidarti ad essa per la convalida del testo. Analizzare il testo per riconoscerne la sintassi è un compito difficile, per alcuni formati, e in qualche caso gli autori delle regole di riconoscimento sono orgogliosi quando riescono a rendere correttamente il 98% del testo, sebbene molto spesso devi usare uno stile molto raro per vedere il 2% scorretto.

Puoi scaricare definizioni per l'evidenziazione della sintassi aggiornate o aggiuntive dal sito Web di &kappname;, facendo clic sul pulsante Scarica file di evidenziazione... dalla linguetta Modi & tipi di file della finestra di configurazione.

## Il sistema di evidenziazione della sintassi di &kappname;

Questa sezione tratta del meccanismo di evidenziazione della sintassi di &kappname; in maggior dettaglio. È per chi voglia saperne di più o per chi voglia creare o modificare le definizioni della sintassi.

### Come funziona

Quando apri un file, una delle prime attività svolte da &kappname; è l'identificazione della definizione della sintassi da usare per tale file. Leggendo il testo del file, o quando tu lo immetti, il sistema di evidenziazione analizza il testo usando le regole definite dalle definizioni della sintassi e si segna dove i diversi contesti e stili iniziano e finiscono.

Quando scrivi nel documento, il nuovo testo è analizzato e catalogato al volo, quindi de elimini un carattere che è indicato come l'inizio o la fine di un contesto, lo stile del testo adiacente cambierà di conseguenza.

Le definizioni delle sintassi usate dal sistema di evidenziazione della sintassi di &kappname; sono file &XML; contenenti

- Regole per identificare il ruolo del testo, organizzato in blocchi contestuali

- Elenco delle parole chiave

- Definizione degli elementi di stile

Quando viene analizzato il testo, le regole di identificazione sono valutate nell'ordine in cui sono definite, e se l'inizio della stringa attuale corrisponde ad una regola, il contesto correlato viene usato. Il punto iniziale del testo è spostato al punto finale in cui la regola corrisponde, e viene eseguito un nuovo ciclo sulle regole, iniziando nel contesto della regola applicata.

### Regole

Le regole di identificazione sono il cuore del sistema di evidenziazione. Una regola è una stringa, un carattere o una espressione regolare da confrontare con il testo da analizzare. Contiene informazioni su quale stile usare per la parte del testo a cui corrisponde. Può cambiare il contesto di lavoro del sistema o ad un contesto esplicitamente menzionato o al precedente contesto usato dal testo.

Le regole sono organizzate in gruppi di contesti. Un gruppo di contesti è usato per i concetti principali del testo all'interno del formato, ad esempio stringhe di caratteri virgolettate o blocchi di commento nei sorgenti di programma. Ciò assicura che il sistema di evidenziazione non debba controllare tutte le regole quando non è necessario, e che alcune sequenze di caratteri possano essere trattate in modo diverso a seconda del contesto attuale.

I contesti possono essere generati dinamicamente per permettere l'uso di dati specifici per le istanze nelle regole.

### Stili del contesto e parole chiave

In alcuni linguaggi di programmazione i numeri interi sono trattati dal compilatore (il programma che converte il codice sorgente in eseguibile binario) in modo diverso dai numeri in virgola mobile, e ci possono essere caratteri con significati speciali all'interno delle stringhe fra virgolette. In questi casi, ha senso che vengano composti tipograficamente in modo diverso rispetto al testo circostante, in modo che siano riconoscibili facilmente. Quindi anche se non rappresentano un contesto speciale, possono essere visti in tal modo dal sistema di evidenziazione, perché possano essere resi in modo diverso.

Una definizione di sintassi può contenere tanti stili quanti sono richiesti per coprire i concetti del formato per cui è usata.

In molti formati, ci sono elenchi di parole che rappresentano un concetto specifico. Ad esempio nei linguaggi di programmazione, le istruzioni di controllo sono un concetto, i nomi dei tipi di dato sono un altro, le funzioni built-in di un linguaggio un terzo. Il sistema di evidenziazione di &kappname; può usare questi elenchi per identificare ed indicare le parole del testo in modo da enfatizzare i concetti dei formati di testo.

### Stili predefiniti

Se apri un file sorgente C++ o &Java; o un documento HTML in &kappname;, vedrai che anche se i formati sono diversi, e quindi parole diverse sono scelte per un trattamento speciale, i colori usati sono gli stessi. Ciò è dovuto al fatto che &kappname; ha un elenco di stili predefiniti che sono usati nelle varie definizioni di sintassi.

Ciò rende più semplice riconoscere concetti simili nei vari formati di testo. Ad esempio i commenti sono presenti in quasi tutti i linguaggi per la programmazione, gli script e l'annotazione, e se sono mostrati con lo stesso stile in tutti i linguaggi, non è necessario fermarsi a pensare per identificarli all'interno del testo.

Tutti gli stili di una definizione di sintassi usano uno degli stili predefiniti. Alcune definizioni di sintassi usano più stili di quelli presenti fra i predefiniti, quindi se usi spesso un formato, può essere utile avviare la finestra di configurazione per vedere se alcuni concetti usano lo stesso stile. Ad esempio c'è un solo stile predefinito per le stringhe, ma poiché il linguaggio di programmazione Perl usa due tipi di stringhe distinti, puoi migliorare l'evidenziazione configurando i due tipi per avere un aspetto leggermente diverso. Tutti gli stili predefiniti disponibili sono spiegati in dettaglio in seguito.

## Il formato &XML; di definizione dell'evidenziazione

### Panoramica

Questa sezione è una panoramica del formato &XML; di definizione dell'evidenziazione. Partendo da un breve esempio, descriverà le componenti principali ed il loro significato ed uso. La sezione successiva approfondirà i dettagli delle regole di identificazione per l'evidenziazione.

La definizione formale, anche nota come DTD, è memorizzata nel file `language.dtd` che dovrebbe essere installato sul tuo sistema nella cartella `$`KDEDIR`/share/apps/katepart/syntax`.

### Sezioni principali dei file di definizione dell'evidenziazione di &kappname;

Un file di evidenziazione contiene un'intestazione che stabilisce la versione di XML ed il tipo di documento:

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

La radice del file di definizione è l'elemento `language`. Gli attributi disponibili sono:

- Attributi obbligatori:

  `name` definisce il nome del linguaggio. Apparirà nei menu e nelle finestre di dialogo.

  `section` specifica la categoria.

  `extensions` definisce le estensioni dei file, come "*.cpp,*.h"

  Attributi opzionali:

  `mimetype` associa i file basati sui tipi &MIME;.

  `version` specifica la versione attuale del file di definizione.

  `kateversion` specifica l'ultima versione di &kappname; supportata.

  `casesensitive` specifica se le parole chiave fanno distinzione fra maiuscole e minuscole o no.

  `priority` è un campo necessario se un altro file di evidenziazione usa la stessa estensione. Il file di definizioni che ha la priorità più alta vince.

  `author` contiene il nome dell'autore ed il suo indirizzo di posta elettronica.

  `license` contiene la licenza di distribuzione, solitamente LGPL, Artistic, GPL o altre.

  `hidden` definisce se il nome debba apparire nei menu di &kappname;.

  Quindi la successiva riga potrebbe assomigliare a questa:

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

Segue l'elemento `highlighting`, che contiene l'elemento opzionale `list`, e gli elementi obbligatori `contexts` e `itemDatas`.

- Gli elementi `list` contengono un elenco di parole chiave. In questo caso le parole chiave sono class e const. Puoi aggiungerne tante quante ne servono.

  L'elemento `contexts` contiene tutti i contesti. Quindi il primo contesto è normalmente quello iniziale per l'evidenziazione. Ci sono due regole nel contesto Normal Text, che corrisponde all'elenco di parole chiave con il nome unnome ed una regola che identifica le virgolette e cambia il contesto a string. Per approfondire la conoscenza delle regole vedi il prossimo capitolo.

  La terza parte è l'elemento `itemDatas`. Contiene tutti gli stili di colore e di tipo di carattere necessari al contesto e alle regole. In questo esempio, gli `itemData` Normal Text, String e Keyword sono usati.

      <highlighting>
          <list name="somename">
            <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>

L'ultima parte della definizione dell'evidenziazione è l'opzionale sezione `general`. Può contenere informazioni sulle parole chiave, sul raggruppamento del codice, sui commenti e sul rientro.

- La sezione `comment` definisce quale sequenza di caratteri introduce un commento su riga singola. Puoi definire anche commenti su più righe usando multiLine con l'attributo aggiuntivo end. Questo è usato se l'utente attiva le azioni per commentare/decommentare.

  La sezione `keywords` definisce se le liste di parole chiave fanno distinzione fra le maiuscole e le minuscole o no. Altri attributi saranno spiegati successivamente.

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

### Le sezioni nel dettaglio

Questa parte descrive tutti gli attributi disponibili per i tag contexts, itemData, keywords, comment, per le pieghe del codice e per il rientro.

L'elemento `context` appartiene al gruppo `contexts`. Un contesto definisce le regole specifiche di un contesto, come che cosa debba succedere se il sistema di evidenziazione raggiunge un fine riga. Gli attributi disponibili sono:

- `name` specifica il nome del contesto. Le regole useranno questo nome per specificare il contesto da usare se la regola corrisponde.

  `lineEndContext` definisce il contesto che verrà usato dal sistema di evidenziazione quando raggiunge la fine di una riga. Ciò può essere il nome di un altro contesto, o `#stay` per non cambiare contesto (⪚ non far niente) o `#pop` che causa l'uscita dal contesto attuale. È possibile usare per esempio `#pop#pop#pop` per risalire di tre livelli.

  `lineEmptyContext` definisce il contesto se una riga vuota è incontrata. Valore predefinito: #stay.

  `falltrough` definisce se il sistema di evidenziazione commuta sul contesto specificato in fallthroughContext in caso di nessuna corrispondenza con una regola. Valore predefinito: false.

  `fallthroughContext` specifica il contesto successivo se nessuna regola corrisponde.

  `dynamic` se vale true fa in modo che il contesto ricordi le stringhe/segnaposto salvati dalle regole dinamiche. Ciò è necessario per i documenti HERE, ad esempio. Valore predefinito: false.

L'elemento `itemData` è nel gruppo `itemDatas`. Definisce lo stile dei caratteri ed i colori. Quindi puoi definire stili e colori come preferisci, ma è buona norma usare gli stili predefiniti se possibile, in modo da usare gli stessi colori in linguaggi diversi. Però a volte non c'è altro modo ed è necessario cambiare gli attributi di colore e tipo di carattere. Gli attributi name e defStyleNum sono obbligatori, gli altri facoltativi. Gli attributi disponibili sono:

- `name` fornisce il nome dell'itemData. I contesti e le regole useranno tale nome nell'attributo attribute per riferirsi ad un itemData.

  `defStyleNum` definisce quale stile predefinito usare. Gli stili predefiniti sono spiegati nel dettaglio più avanti.

  `color` definisce un colore. I formati validi sono "#rrvvbb" o "#rvb".

  `selColor` definisce il colore della selezione.

  `italic` se vale true, il testo sarà in corsivo.

  `bold` se è true, il testo sarà in grassetto.

  `underline` se è true, il testo sarà sottolineato.

  `strikeout` se è true, il testo sarà barrato.

  Se `spellChecking` è true, verrà eseguito il controllo ortografico, altrimenti verrà ignorato.

L'elemento `keywords` nel gruppo `general` definisce le proprietà delle parole chiave. Gli attributi disponibili sono:

- `casesensitive` può esser true o false. Se è true tutte le parole chiave verranno confrontate facendo distinzione tra maiuscole e minuscole.

  `weakDeliminator` è un elenco di caratteri che non si comportano come delimitatori di parole. Ad esempio il punto `"."` è un delimitatore di parola. Assumendo che una parola chiave contenga un punto, potrà corrispondere al testo solo se il punto viene definito come delimitatore debole.

  `additionalDeliminator` definisce delimitatori aggiuntivi.

  `wordWrapDeliminator` definisce i caratteri dopo i quali è ammissibile un a capo automatico.

  I delimitatori predefiniti ed i delimitatori di confine parola sono i caratteri `.():!+,-<=>%&*/;?[]^{|}~\`, spazio (`' '`) e tabulazione (`'\t'`).

L'elemento `comment` del gruppo `comments` definisce le proprietà dei commenti che sono usate per Strumenti Commenta e Strumenti Decommenta. Gli attributi disponibili sono:

- `name` è o singleLine o multiLine. Se scegli multiLine gli attributi end e region sono obbligatori.

  `start` definisce la stringa usata per iniziare un commento. In C++ questa sarebbe "/*".

  `end` definisce la stringa usata per chiudere un commento. In C++ essa sarebbe "*/".

  `region` deve essere il nome del commento su più righe raggruppabile. Poniamo che tu abbia beginRegion="Comment" ... endRegion="Comment" fra le regole; in questo caso devi usare region="Comment". Così decommentare è possibile anche senza selezionare tutto il testo del commento su più righe. Basta che il cursore sia all'interno del commento.

L'elemento `folding` del gruppo `general` definisce le proprietà del raggruppamento. Gli attributi disponibili sono:

- `indentationsensitive` se true, gli indicatori di raggruppamento del codice saranno aggiunti in base al rientro, come per il linguaggio per gli script Python. Di solito non è necessaria una dichiarazione esplicita, perché in assenza di dichiarazione, viene considerato false.

L'elemento `indentation` del gruppo `general` definisce quale algoritmo di rientro verrà usato, ma si raccomanda fortemente di omettere questo elemento, perché il rientratore verrà normalmente scelto o con la definizione di un tipo di file o con l'aggiunta di una variabile del documento nel file di testo. Se specifichi un rientratore invece, obbligherai l'utente ad usare un sistema di rientro particolare, che potrebbe non gradire. Gli attributi disponibili sono:

- `mode` è il nome del rientratore. I rientratori disponibili attualmente sono: normal, cstyle, haskell, lilypond, lisp, python, ruby e xml.

### Stili predefiniti disponibili

Gli stili predefiniti sono stati già spiegati, ma riassumendo: gli stili predefiniti sono gli stili di colorazione e dei tipi di carattere.

Ecco quindi un elenco degli stili predefiniti disponibili:

- `dsNormal`, usato per il testo normale.

  `dsKeyword`, usato per le parole chiave.

  `dsDataType`, usato per i tipi di dato.

  `dsDecVal`, usato per i valori decimali.

  `dsBaseN` usato per i valori con una base diversa da 10.

  `dsFloat`, usato per i valori in virgola mobile.

  `dsChar`, usato per i singoli caratteri.

  `dsString`, usato per le stringhe.

  `dsComment`, usato per i commenti.

  `dsOther`, usato per "altre" cose.

  `dsAlert`, usato per i messaggi di attenzione.

  `dsFunction`, usato per le chiamate di funzione.

  `dsRegionMarker`, usato per gli indicatori di regione.

  `dsError`, usato per l'evidenziazione degli errori e per la sintassi sbagliata.

## Regole per la determinazione dell'evidenziazione

Questa sezione descrive le regole per la determinazione dell'evidenziazione.

Ogni regola può corrispondere a zero o più caratteri all'inizio della stringa con cui sono confrontati. Se la regola corrisponde, ai caratteri corrispondenti è assegnato lo stile o l'attributo definito dalla regola, ed una regola può chiedere di cambiare il contesto attuale.

Una regola ha questo aspetto:

    <RuleName attribute="(identificatore)" context="(identificatore)" [attributi specifici della regola] />

attribute identifica per nome lo stile da usare per i caratteri corrispondenti alla regola, e context identifica il contesto da usare da questo punto in poi.

Il contesto può essere identificato da:

- Un identificatore, che è il nome di un altro contesto.

- Un ordine che indica al motore di stare nel contesto attuale (#stay) o di tornare ad un contesto precedentemente usato nella stringa (`#pop`).

  Per tornare indietro di più di un passo, la parola chiave #pop può essere ripetuta: `#pop#pop#pop`

Alcune regole possono avere regole figlie che sono valutate solo se la regola madre corrisponde. All'intera stringa corrispondente sarà dato l'attributo della regola madre. Una regola con delle regole figlie ha questo aspetto:

    <RuleName (attributes)>
      <ChildRuleName (attributes) />
      ...
    </RuleName>

Gli attributi specifici di ogni regola variano e sono descritti nelle sezioni seguenti.

## Attributi comuni

Tutte le regole hanno i seguenti attributi in comune che sono disponibili ogni volta che appare `attributi comuni)`. attribute e context sono attributi obbligatori, gli altri sono facoltativi.

- attribute: un attributo si applica ad un itemData definito.

- context: Specifica il contesto da usare nel caso in cui la regola corrisponda.

- beginRegion: inizia un blocco di ripiegamento del codice. Valore predefinito: non impostato.

- endRegion: chiude un blocco di ripiegamento del codice. Valore predefinito: non impostato.

- lookAhead Se vale true il sistema di evidenziazione non processa la lunghezza combaciante. Valore predefinito: false.

- firstNonSpace: corrisponde solo se la stringa è composta dai primi caratteri non bianchi di una riga. Valore predefinito: false.

- column: Corrisponde solo se la colonna corrisponde. Valore predefinito: non impostato.

## Regole dinamiche

Alcune regole permettono l'uso dell'attributo `dynamic` di tipo booleano, con valore predefinito false. Se dynamic è true, una regola può usare segnaposto rappresentanti il testo corrispondente da una regola espressione regolare che cambia il contesto attuale nel suo attributo `string` o `char`. Se si usa `string`, il segnaposto `%N` (dove N è un numero) sarà sostituito con la corrispondente cattura `N` dell'espressione regolare. In un `char` il segnaposto deve essere un numero `N` e sarà sostituito con il primo carattere della corrispondente cattura `N` dell'espressione regolare chiamante. Quando una regola permette questo attributo, conterrà nella sinossi la dicitura (dynamic).

- dynamic può essere (true|false).

### Le regole nel dettaglio

DetectChar

- Identifica un singolo carattere specifico. Usata comunemente per trovare ad esempio la fine di una stringa virgolettata.

      <DetectChar char="(carattere)" (attributi comuni) (dynamic) />

  L'attributo `char` definisce il carattere che deve corrispondere.

Detect2Chars

- Identifica due caratteri specifici in un ordine stabilito.

      <Detect2Chars char="(carattere)" char1="(carattere)" (attributi comuni) (dynamic) />

  L'attributo `char` definisce il primo carattere che deve corrispondere, `char1` il secondo.

AnyChar

- Identifica un carattere appartenente ad uno specifico insieme di caratteri.

      <AnyChar String="(stringa)" (attributi comuni) />

  L'attributo `String` definisce l'insieme di caratteri.

StringDetect

- Identifica una stringa esattamente corrispondente.

      <StringDetect String="(stringa)" [insensitive="true|false"] (attributi comuni) (dynamic) />

  L'attributo `String` definisce la stringa da confrontare. L'attributo `insensitive` vale false, se omesso, ed è passato alla funzione per la comparazione delle stringhe. Se il suo valore è true, verrà usata una comparazione senza distinzione fra maiuscole e maiuscole.

WordDetect

- Rileva una stringa esatta e, in aggiunta, richiede i bordi di parola come il punto `«.»` oppure uno spazio bianco all'inizio e alla fine della parola. Pensa a `\b<stringa>\b` nei termini di una espressione regolare, è più veloce della regola `RegExpr`.

      <WordDetect String="(string)" [insensitive="true|false"] (common attributes) (dynamic) />

  L'attributo `String` definisce la stringa da confrontare. L'attributo `insensitive` vale false, se omesso, ed è passato alla funzione per la comparazione delle stringhe. Se il suo valore è true, verrà usata una comparazione senza distinzione fra maiuscole e maiuscole.

  Da Kate 3.5 (KDE 4.5)

RegExpr

- Corrispondenza con un'espressione regolare.

      <RegExpr String="(stringa)" [insensitive="true|false"] [minimal="true|false"] (attributi comuni) (dynamic) />

  L'attributo `String` definisce l'espressione regolare.

  `insensitive` vale false normalmente,ed è passato al motore delle espressioni regolari.

  `minimal` vale false normalmente,ed è passato al motore delle espressioni regolari.

  Poiché le regole sono confrontate sempre con l'inizio della stringa corrente, un'espressione regolare che inizi con un carattere di accento circonflesso (`^`) indica che la regola debba combaciare solo all'inizio di una riga.

  Vedi la sezione sulle espressioni regolari per maggiori informazioni a riguardo.

keyword

- Rivela una parola chiave da un elenco specificato.

      <keyword String="(nome lista)" (attributi comuni) />

  L'attributo `String` identifica la lista di parole chiave per nome. Deve essere presente una lista con tale nome.

Int

- Rivela un numero intero.

      <Int (attributi comuni) (dynamic) />

  Questa regola non ha attributi specifici. Le regole figlie di solito si usano per trovare combinazioni di `L` e `U` dopo un numero, per indicare il tipo di intero nel codice di un programma. In effetti tutte le regole sono ammesse come regole figlie, anche se il DTD permette solo la regola figlia `StringDetect`.

  L'esempio seguente corrisponde ai numeri interi seguiti dal carattere "L".

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

Float

- Rivela un numero in virgola mobile.

      <Float (attributi comuni) />

  Questa regola non ha attributi specifici. `AnyChar` è ammesso come regola figlia ed è tipicamente usata per identificare le combinazioni, vedi la regola `Int` come riferimento.

HlCOct

- Rivela la rappresentazione ottale di un numero.

      <HlCOct (attributi comuni) />

  Questa regola non ha attributi specifici.

HlCHex

- Rivela la rappresentazione esadecimale di un numero.

      <HlCHex (attributi comuni) />

  Questa regola non ha attributi specifici.

HlCStringChar

- Rivela una sequenza di escape.

      <HlCStringChar (attributi comuni) />

  Questa regola non ha attributi specifici.

  Corrisponde a rappresentazioni letterali di caratteri comunemente usati nel codice dei programmi, come ad esempio `\n` (nuova riga) o `\t` (TAB).

  Corrisponde ai seguenti caratteri se seguono una barra inversa (`\`): `abefnrtv"'?\`. In più, corrisponde alle sequenze di escape con i numeri esadecimali come `\xff` e con i numeri ottali, come `\033`.

HlCChar

- Rivela un carattere C.

      <HlCChar (attributi comuni) />

  Questa regola non ha attributi specifici.

  Corrisponde ai caratteri C racchiusi fra apici singoli (Esempio: `'c'`). Quindi fra gli apici può trovarsi un carattere semplice o un carattere preceduto da un carattere di escape. Vedi HlCStringChar per sapere quali sequenze di escape siano contemplate.

RangeDetect

- Identifica una stringa con dei caratteri di inizio e fine definiti.

      <RangeDetect char="(carattere)"  char1="(carattere)" (attributi comuni) />

  `char` definisce il carattere che inizia la sequenza, `char1` il carattere che termina la sequenza.

  È utile per trovare ad esempio brevi stringhe racchiuse fra virgolette o simili, ma nota che poiché il motore di evidenziazione funziona ad una riga per volta, questa regola non può trovare stringhe che continuano su più di una riga.

LineContinue

- Corrispondenza con la barra rovescia (`'\'`) alla fine della riga.

      <LineContinue (attributi comuni) />

  Questa regola non ha attributi specifici.

  Questa regola è utile per cambiare contesto alla fine di una riga, se l'ultimo carattere è una barra inversa (`'\'`). Ciò è necessario ad esempio in C/C++ per continuare le macro o le stringhe.

IncludeRules

- Include regole di un altro contesto o di un altro linguaggio o file.

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

  L'attributo `context` definisce quale contesto includere.

  Se è una semplice stringa, include tutte le regole definite nel contesto attuale, ad esempio:

      <IncludeRules context="unAltroContesto" />

  Se la stringa comincia con `##` il sistema di evidenziazione cercherà un'altra definizione di linguaggio con il nome dato, ad esempio:

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

  Se l'attributo `includeAttrib` è true, cambia l'attributo di destinazione a quello del sorgente. Ciò è necessario, ad esempio, per far funzionare i commenti, se il testo a cui corrisponde il contesto incluso è di evidenziazione diversa da quello del contesto ospite.

DetectSpaces

- Rileva gli spazi bianchi.

      <DetectSpaces (attributi comuni) />

  Questa regola non ha attributi specifici.

  Usa questa regola se sai che si possono incontrare molti spazi bianchi, ad esempio all'inizio di righe rientrate. La regola salta tutti gli spazi in una volta, invece di provare più regole e saltarne uno per volta per mancanza di corrispondenza.

DetectIdentifier

- Rivela le stringhe degli identificatori (come espressione regolare: [a-zA-Z_][a-zA-Z0-9_]*).

      <DetectIdentifier (attributi comuni) />

  Questa regola non ha attributi specifici.

  Usa questa regola per saltare una stringa di caratteri di parola in una volta, invece di provare più regole per saltare un carattere per volta per mancanza di corrispondenza.

### Suggerimenti e trucchi

Quando avrai capito come funziona il cambio di contesto sarà facile scrivere le tue definizioni. Però devi stare attento a quali regole scegli in quale situazione. Le espressioni regolari sono potenti, ma sono lente in confronto alle altre regole. Quindi ti conviene seguire i seguenti consigli.

- Se devi confrontare solo due caratteri, usa `Detect2Chars` invece di `StringDetect`. Lo stesso si applica a `DetectChar`.

- Le espressioni regolari sono comode ma spesso c'è un modo molto più veloce per ottenere lo stesso risultato. Considera di volere una corrispondenza co il carattere `'#'` se è il primo carattere di una riga. Una soluzione basata sulle espressioni regolari avrà questo aspetto:

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

  Puoi ottenere lo stesso effetto molto più rapidamente usando:

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

  Se vuoi una corrispondenza con l'espressione regolare`'^#'` puoi comunque usare `DetectChar` con l'attributo `column="0"`. L'attributo `column` conta le colonne in base ai caratteri, quindi un tabulatore è ancora un solo carattere.

- Puoi cambiare contesto senza processare caratteri. Poniamo che tu voglia cambiare contesto quando incontri la stringa `*/`, ma che debba processare la stringa nel prossimo contesto. La regola seguente corrisponderà, e l'attributo `lookAhead` farà mantenere all'evidenziatore la stringa corrispondente per il prossimo contesto.

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

- Usa `DetectSpaces` se sai che capitano molti spazi bianchi.

- Usa `DetectIdentifier` invece dell'espressione regolare `'[a-zA-Z_]\w*'`.

- Usa gli stili predefiniti ogni volta che puoi. In questo modo l'utente si troverà in un ambiente familiare.

- Esamina gli altri file XML per vedere come altri hanno implementato regole complesse.

- Puoi convalidare tutti i file XML usando il comando `xmllint --dtdvalid language.dtd miaSintassi.xml`.

- Se usi più volte delle espressioni regolari complesse, puoi usare le ENTITÀ. Esempio:

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

  Ora puoi usare &myref; invece dell'espressione regolare.