# Travailler avec la coloration syntaxique

## Vue d'ensemble

La coloration syntaxique est ce qui fait automatiquement afficher du texte à l'éditeur dans différents styles / couleurs selon la fonction de la chaîne en rapport avec le but du fichier. Dans le code source d'un programme par exemple, des instructions de contrôle peuvent être rendues en gras, alors que des types de données et des commentaires prennent des couleurs différentes du reste du texte. Ceci améliore considérablement la lisibilité du texte et aide ainsi l'auteur à être plus efficace et plus productif.

De ces deux exemples, lequel est le plus facile à lire ?

&kate; offre un système souple, configurable et capable de prendre en charge la coloration syntaxique ; la distribution standard fournit des définitions d'un large éventail de langages de programmation, de balisage et de scriptage, ainsi que d'autre formats de fichiers texte. En outre, vous pouvez proposer vos propres définitions dans des fichiers &XML; simples.

&kate; détecte automatiquement les règles de coloration syntaxique lorsque vous ouvrez un fichier, en fonction du type &MIME;, déterminé par son extension ou, s'il n'y en a aucune, le contenu. Si vous vous faites un mauvais choix, vous pouvez définir manuellement la syntaxe à utiliser dans le menu Documents Mode de coloration syntaxique.

Les styles et les couleurs utilisés par chaque définition de coloration syntaxique, ainsi que les types &MIME; à employer, peuvent être configurés à l'aide de la page Coloration syntaxique de la boîte de dialogue Configuration.

La coloration syntaxique est là pour améliorer la lisibilité du texte correct, mais vous ne pouvez pas vous y fier pour valider votre texte. La complexité du marquage syntaxique du texte dépend du format que vous utilisez et, dans certains cas, les auteurs des règles de syntaxe seront fiers si 98 % du texte sont correctement rendus, même si la plupart du temps, il vous faut un style rare pour voir les 2 % incorrects.

Vous pouvez télécharger des définitions de coloration syntaxique actualisées ou additionnelles sur le site web de &kate; en cliquant sur le bouton Télécharger dans la page Coloration syntaxique de la boîte de dialogue de Configuration.

## Le système de coloration syntaxique de &kate;

Cette section aborde le mécanisme de coloration syntaxique de &kate; plus en détail. Il vous conviendra si vous voulez en faire l'apprentissage, créer ou changer des définitions de syntaxe.

### Fonctionnement

Chaque fois que vous ouvrez un fichier, une des premières tâches de l'éditeur &kate; est de détecter la définition syntaxique à utiliser pour le fichier. Lors de la lecture du texte du fichier, et lors de sa saisie dans ce dernier, le système de coloration syntaxique analysera le texte à l'aide des règles fixées par la définition syntaxique et y marquera les endroits où différents contextes et styles commencent et finissent.

Lorsque vous saisissez le document, le nouveau texte est analysé et marqué à la volée, de sorte que si vous supprimez un caractère qui est marqué comme étant le commencement ou la fin d'un contexte, le style du texte environnant change en conséquence.

Les définitions syntaxiques que le système de coloration syntaxique de &kate; utilise sont des fichiers &XML; contenant

- Des règles pour détecter le rôle du texte, organisé en blocs de contexte

- Des définitions d'éléments de style

Lors de l'analyse du texte, les règles de détection sont évaluées dans l'ordre dans lequel elles sont définies et si le début de la chaîne actuelle correspond à une règle, le contexte y afférent est utilisé. Le point de départ dans le texte est déplacé vers le point final auquel cette règle correspondait et une nouvelle boucle des règles commence, en partant du contexte établi par la règle qui correspondait.

### Règles

Les règles de détection sont le fondement du système de détection de la coloration syntaxique. Une règle est une chaîne, un caractère ou uneexpression rationnellepar rapport à laquelle faire correspondre le texte en cours d'analyse. Elle contient des informations sur le style à utiliser pour la partie correspondante du texte. Elle peut basculer le contexte de fonctionnement du système soit vers un contexte explicitement mentionné, soit vers le précédent contexte utilisé par le texte.

Les règles sont organisées en groupes de contexte. Un groupe de contexte est utilisé pour la majorité des concepts textuels au sein du format, par exemple des chaînes de texte entre guillemets ou des blocs de commentaires dans le code source d'un programme. Cela garantit que le système de coloration n'a pas besoin d'itérer sur toutes les règles lorsque ce n'est pas nécessaire et que certaines séquences de caractères dans le texte peuvent être traitées différemment en fonction du contexte actuel.

### Styles de contexte et mots-clés

Dans certains langages de programmation, les nombres entiers sont traités différemment des nombres à virgule flottante par le compilateur (le programme qui convertit le code source en exécutable binaire) et on peut trouver des caractères ayant une signification spéciale au sein d'une chaîne entre guillemets. Dans de tels cas, il est judicieux de les rendre différemment de ceux qui sont voisins pour qu'ils soient faciles à identifier lors de la lecture du texte. Donc, même s'ils ne représentent pas des contextes spéciaux, ils peuvent être considérés comme tels par le système de coloration syntaxique, de façon à pouvoir être marqués pour un rendu différent.

Une définition syntaxique peut contenir autant de styles que nécessaire pour couvrir les concepts du format pour lequel elle est utilisée.

Dans de nombreux formats, il y a des listes de mots qui représentent un concept spécifique. Par exemple, dans les langages de programmation, les instructions de contrôle sont un concept, les noms de types de données un autre et les fonctions intégrées du langage un troisième. Le système de coloration syntaxique de &kate; peut faire appel à de telles listes pour détecter et marquer des mots dans le texte afin de mettre en exergue les concepts des formats de texte.

### Styles par défaut

Si vous ouvrez un fichier source en C++, un fichier source &Java; et un document HTML dans &kate;, vous constatez que même si les formats sont différents et donc, que des mots différents sont choisis pour un traitement spécial, les couleurs utilisées sont les mêmes. C'est parce que &kate; a une liste prédéfinie de styles par défaut qui sont employés par les définitions syntaxiques individuelles.

Ceci facilite la reconnaissance de concepts similaires dans différents formats de texte. Par exemple, les commentaires sont présents dans presque tout langage de programmation, de scriptage ou de balisage et, lorsqu'ils sont rendus à l'aide du même style dans tous les langages, vous n'avez pas à vous arrêter et à penser à les identifier au sein du texte.

Dans une définition syntaxique, tous les styles utilisent un des styles par défaut. Comme quelques définitions syntaxiques utilisent davantage de styles qu'il n'y en a par défaut, si vous utilisez fréquemment un format, il peut valoir la peine d'ouvrir la boîte de dialogue de configuration pour voir si certains concepts utilisent le même style. Par exemple, il n'y a qu'un style par défaut pour les chaînes, mais comme le langage de programmation Perl fait appel à deux types de chaînes, vous pouvez améliorer la surbrillance en les configurant de manière à les rendre légèrement différentes.

## Le format &XML; de définition de la surbrillance

### Vue d'ensemble

Cette section est une vue d'ensemble du format &XML; de définition de la surbrillance. Elle décrit les principaux composants, leur signification et leur usage, sans oublier de détailler les règles de détection.

La définition formelle, autrement dit la DTDest stockée dans le fichier `language.dtd` qui, dans votre système, devrait être installé dans le répertoire `$`KDEDIR`/share/apps/kate/syntax`.

#### Principaux composants des définitions de coloration syntaxique de &kate;

La section Général

  La section Général contient des informations sur le format de commentaire du langage décrit et détermine si les mots-clés sont sensibles à la casse.

Coloration syntaxique

  La section Coloration syntaxique contient toutes les données requises pour analyser et rendre le texte. Elle inclut :

  ItemDatas

    Contient des éléments ItemData, dont chacun définit un style.

    Chaque liste a un nom et peut contenir un nombre quelconque d'éléments.

  Contextes

    Contient des contextes, qui contiennent à leur tour les règles de détection syntaxique.

## Règles de détection de la coloration syntaxique

Cette section décrit les règles de détection syntaxique.

Chaque règle peut correspondre à zéro ou plusieurs caractères au début de la chaîne qu'il lui est demandé de tester. Si la règle correspond, les caractères concordants sont affectés au style ou à l'attribut défini par la règle et une règle peut demander que le contexte actuel soit commuté.

Les attributs et les attributs de contexte sont communs à toutes les règles.

Une règle ressemble à ceci :

    <RuleName attribute="(identifier)" context="(identifier|order)" [rule specific attributes] />

L'attribut identifie le style à utiliser pour les caractères correspondants par nom ou index et le contexteidentifie le contexte à utiliser à partir de là.

L'attribut peut être identifié soit par son nom, soit par son index basé sur zéro dans le groupe ItemDatas.

Le contexte peut être identifié par :

- Un identifiant, pour l'instant seulement son index basé sur zéro dans le groupe de contextes.

- Un ordre indiquant au moteur de rester dans le contexte actuel (`#stay`) ou de revenir à un contexte précédemment utilisé dans la chaîne (`#pop`).

  Pour reculer de plusieurs étapes, le mot-clé #pop peut être répété : `#pop#pop#pop`

Certaines règles peuvent avoir des règles filles qui sont ensuite évaluées si, et seulement si la règle mère correspondait. La chaîne entière concordante se verra affecter l'attribut défini par la règle mère. Une règle ayant des règles filles ressemble à ceci :

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

Les attributs spécifiques à une règle varient et sont décrits dans la liste suivante.

### Les règles en détail

DetectChar

  Détecte un seul caractère spécifique. Communément utilisée par exemple pour trouver les extrémités de chaînes entre guillemets.

      <DetectChar char="(character)" (attributs communs) />

  L'attribut `char` définit le caractère à faire correspondre.

Detect2Chars

  Détecte deux caractères spécifiques dans un ordre défini.

      <Detect2Chars char="(caractère)" char1="(caractère)" (attributs communs) />

  L'attribut `char` définit le premier caractère à faire correspondre, `char1` le second.

AnyChar

  Détecte un caractère d'un jeu de caractères spécifié.

      <AnyChar String="(chaîne)" (attributs communs) />

  L'attribut `String` définit le jeu de caractères.

StringDetect

  Détecte une chaîne exacte.

      <StringDetect String="(chaîne)" [insensitive="TRUE|FALSE;"] (attributs communs) />

  L'attribut `String` définit la chaîne à faire correspondre. L'attribut `insensitive` fixe la valeur par défaut à `FAUX` et est introduit dans la fonction de comparaison de a chaîne. Si la valeur est `VRAI`, une comparaison insensible est utilisée.

RegExpr

  Concorde par rapport à une expression rationnelle.

      <RegExpr String="(chaîne)" [insensitive="TRUE|FALSE;"] [minimal="TRUE|FALSE"] (attributs communs) />

  L'attribut `String` définit l'expression rationnelle.

  `insensitive` est défini par défaut à `FAUX` et introduit dans le moteur d'expression rationnelle.

  `minimal` est défini par défaut à `FAUX` et introduit dans le moteur d'expression rationnelle.

  Du fait que les règles sont toujours concordantes par rapport au début de la chaîne actuelle, une expression rationnelle commençant par un caret (`^`) indique que la règle ne devrait être concordante que par rapport au début d'une ligne.

  Consultez Expressions rationnelles pour plus d'informations à ce sujet.

Keyword

  Détecte un mot-clé dans une liste donnée.

      <keyword String="(nom de liste)" (attributs communs) />

  L'attribut `String` identifie la liste de mots-clés par nom. Une liste contenant ce nom doit exister.

Int

  Détecte un nombre entier.

      <Int (attributs communs) />

  Cette règle n'a aucun attribut spécifique. Des règles filles sont généralement utilisées pour détecter des combinaisons de `L` et de `U` après le nombre, indiquant le type d'entier dans le code de programme.

Flottant

  Détecte un nombre à virgule flottante.

      <Float (attributs communs)
      />

  Cette règle n'a aucun attribut spécifique.

HlCOct

  Détecte une représentation d'un nombre octal.

      <HlCOct (attributs communs) />

  Cette règle n'a aucun attribut spécifique.

HlCHex

  Détecte une représentation d'un nombre en hexadécimal.

      <Int (attributs communs) />

  Cette règle n'a aucun attribut spécifique.

HlCStringChar

  Détecte un caractère échappé.

      <HlCStringChar (attributs communs)
      />

  Cette règle n'a aucun attribut spécifique.

  Elle correspond à des représentations par des lettres de caractères invisibles communément utilisés dans du code de programme, par exemple `\n` (saut de ligne) ou `\t` (tabulation).

  Les caractères suivants correspondront s'ils suivent une barre oblique inverse (`\`) : `abefnrtv"'?`. En outre, les nombres d'échappement en hexadécimal comme par exemple `\xff` et les nombres échappés en octal, par exemple `\033` correspondront.

RangeDetect

  Détecte une chaîne dont les caractères de début et de fin sont définis.

      <RangeDetect char="(caractère)"  char1="(caractère)" (attributs communs) />

  `char` définit le caractère démarrant la plage, `char2` le caractère terminant la plage.

  Utile pour détecter par exemple de petites chaînes entre guillemets et similaires; mais notez que, puisque le moteur de surbrillance fonctionne sur une ligne à la fois, il ne trouvera pas de chaînes s'étendant au-delà d'un saut de ligne.

LineContinue

  Correspond à la fin de la ligne.

      <LineContinue (attributs communs) />

  Cette règle n'a aucun attribut spécifique.

  Cette règle est utile pour commuter un contexte à la fin de la ligne.