Référence : langages colorés

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294

# Référence : langages colorés

> Description neutre des fichiers que Turbo Golo colore, de la façon dont il décide, et de ce que chaque scanner reconnaît.

## Reconnaissance

L'**extension** d'un fichier décide dès qu'elle est l'une de celles-ci :

| Extension | Langage |
| --- | --- |
| `.golo` | Golo |
| `.toml` | TOML |
| `.yaml`, `.yml` | YAML |
| `.md`, `.markdown` | Markdown |
| `.js`, `.mjs`, `.cjs` | JavaScript |
| `.html`, `.htm` | HTML |
| `.xml`, `.xsd`, `.xsl`, `.xslt`, `.svg`, `.plist`, `.csproj`, `.pom` | XML |
| `.sh`, `.bash`, `.zsh` | Shell |
| `.dockerfile`, `.containerfile` | Dockerfile |

Les extensions sont comparées sans tenir compte de la casse, et seule la dernière compte : `notes.golo.md` est du Markdown, et `main.golo.backup` n'est pas du Golo.

Un fichier dont l'extension ne décide rien est ensuite cherché par son **nom**. Seuls les fichiers sans extension utile en ont besoin :

| Nom | Langage |
| --- | --- |
| `Dockerfile`, `Containerfile` | Dockerfile |

Un nom correspond sur sa totalité ou sur la partie avant le premier point, sans tenir compte de la casse — `Dockerfile`, `dockerfile` et `Dockerfile.dev` sont donc tous reconnus, tandis que `Dockerfile.md` est du Markdown, parce que l'extension est consultée d'abord.

Un fichier que ni l'une ni l'autre table ne réclame est lu par sa **première ligne**. Un shebang nommant `golo` en fait du Golo : `#` ouvre un commentaire en Golo, l'interpréteur lit donc la ligne comme tel, et un script installé sans son extension et lancé comme une commande est du Golo et rien d'autre. Un shebang nommant un shell — `sh`, `bash`, `zsh`, `dash` ou `ksh` — en fait un script shell. L'interpréteur est reconnu comme élément de chemin ou comme argument d'`env`.

| Première ligne | Résultat |
| --- | --- |
| `#!/usr/bin/env golo` | Golo |
| `#!/usr/local/bin/golo` | Golo |
| `#!/bin/sh` | Shell |
| `#!/usr/bin/env bash` | Shell |
| `#!/usr/bin/env -S bash -e` | Shell |
| `#!/usr/bin/env node` | Non coloré |
| Tout ce qui ne commence pas par `#!` | Non coloré |

L'ordre est fixe — extension, puis nom, puis première ligne — et le premier qui décide l'emporte.

Tout le reste est affiché en texte brut. Ce n'est pas une erreur — ouvrir un PNG dans l'éditeur n'est pas une faute, c'est juste non coloré.

## Classes

Chaque scanner produit le même vocabulaire de classes, et chacune correspond à une clé de thème.

| Classe | Clé de thème | Produite par |
| --- | --- | --- |
| `identifier` | `syntax.identifier` | Golo, TOML, JavaScript, shell, YAML, Dockerfile |
| `keyword` | `syntax.keyword` | Golo, JavaScript, shell, HTML (doctype), XML, Dockerfile |
| `type` | `syntax.type` | Golo (noms capitalisés et chemins de module), TOML (en-têtes de table), YAML (tags) |
| `builtin` | `syntax.builtin` | Golo (les fonctions de l'interpréteur), JavaScript, shell (builtins et expansions), YAML (ancres et alias), Dockerfile (variables) |
| `constant` | `syntax.constant` | Golo, TOML, JavaScript, shell, YAML, HTML et XML (entités) |
| `function` | `syntax.function` | Golo, JavaScript, shell (la commande) |
| `string` | `syntax.string` | tous |
| `char` | `syntax.char` | Golo (`'c'`) |
| `number` | `syntax.number` | Golo, TOML, JavaScript, shell, YAML, Dockerfile |
| `comment` | `syntax.comment` | Golo, TOML, JavaScript, shell, HTML, YAML, XML, Dockerfile |
| `operator` | `syntax.operator` | Golo, TOML, JavaScript, shell, HTML, YAML (en-têtes de scalaires bloc), XML, Dockerfile |
| `punctuation` | `syntax.punctuation` | Golo, TOML, JavaScript, shell, Markdown, YAML, Dockerfile |
| `heading` | `syntax.heading` | Markdown |
| `tag` | `syntax.tag` | HTML, XML |
| `attribute` | `syntax.attribute` | HTML, XML, Dockerfile (options) |
| `emphasis` | `syntax.emphasis` | Markdown |
| `link` | `syntax.link` | Markdown |

Golo ne produit aucune portée `heading`, `tag`, `attribute`, `emphasis` ou `link`. Dans `turbo-classic`, `syntax.number` et `syntax.constant` sont tous deux magenta et `syntax.char` a le vert de `syntax.string`, si bien que `42` et `true` partagent une couleur là, et `'x'` et `"x"` aussi ; d'autres thèmes les séparent. Voir [écrire son propre thème](../how-to/write-a-theme.md) pour changer cela.

## Golo

Écrit à la main, dans `internal/gololang`, contre `lexer/lexer.go` et `token/token.go` de GoloScript. Ce que le lexer lit comme un token, le scanner le colore comme une portée.

**Quatre constructions franchissent une ligne**, et sont portées à la ligne suivante exactement comme le lexer les lit : un commentaire bloc `----` jusqu'à son `----` fermant ; une chaîne `"…"` jusqu'à son guillemet fermant ; une chaîne multiligne `"""…"""` jusqu'à ses trois guillemets fermants ; un littéral de caractère `'…'` jusqu'à son apostrophe fermante. Aucune des quatre ne s'imbrique. Une chaîne non terminée colore donc le reste du fichier, jusqu'à un guillemet — ce que l'interpréteur lit comme telle.

| Reconnu | Comme |
| --- | --- |
| `and`, `augment`, `augmentation`, `await`, `break`, `case`, `catch`, `continue`, `else`, `finally`, `for`, `foreach`, `function`, `if`, `import`, `in`, `is`, `isnt`, `let`, `local`, `match`, `module`, `not`, `oftype`, `or`, `orIfNull`, `otherwise`, `return`, `spawn`, `struct`, `then`, `throw`, `try`, `union`, `var`, `when`, `while`, `with` | mot-clé |
| `true`, `false`, `null` | constante |
| les 157 builtins de l'interpréteur — `println`, `print`, `str`, `len`, `list`, `map`, `set`, `array`, `vector`, `range`, `readFile`, `toJSON`, `fromJSON`, `httpGet`, `DynamicObject`, … | builtin |
| tout autre nom commençant par une majuscule ASCII — `Point`, `Shape`, `Circle`, `Result_Failure`, `Some` | type |
| le chemin pointé après `module` ou `import` — `hello.World`, `gololang.Errors`, `java.util.List` — en une seule portée | type |
| le nom après `function` — `main` dans `function main = \|args\|` | fonction |
| tout autre nom en minuscules immédiatement avant `(` | fonction |
| tout autre nom : toute lettre ou marque Unicode, `_`, ou un emoji, puis des lettres, des chiffres et les mêmes — `x`, `été`, `名前`, `😀`, `🚀launch` | identifiant |
| `"…"` avec les échappements `\n \t \r \\ \" \' \0 \xHH`, sur plusieurs lignes | chaîne |
| `"""…"""`, sur plusieurs lignes, sans échappement | chaîne |
| `'…'` avec les mêmes échappements, sur plusieurs lignes | caractère |
| `42`, `3.14`, `1.5e-3`, `2E10`, `42L`, `3.14F`, `2.0f` | nombre |
| `#` jusqu'à la fin de la ligne, shebang compris | commentaire |
| `----` … `----`, sur plusieurs lignes | commentaire |
| `..`, `...` | opérateur |
| les suites de `+-*/%=<>!&\|^~?:` — dont `->`, `?:`, `==`, `!=`, `<=`, `>=` | opérateur |
| `()[]{},;` et un `.` seul | ponctuation |
| `$` dans `augment Shape$Circle` | ponctuation |

**Un point rejoint un nombre seulement quand un chiffre le suit.** C'est le test du lexer lui-même, et c'est ce qui garde `1..3` comme un nombre et un intervalle plutôt que le double `1.` et un `.3` égaré.

**Un exposant peut n'avoir aucun chiffre.** Le lexer lit `1e` comme un flottant et laisse le parseur se plaindre, `1e` est donc une seule portée de nombre.

**Un nom capitalisé est un type par convention, pas par règle.** Golo vous laisse écrire `let Count = 1`, et il est coloré comme un type quand même. Les structs, les unions, les variantes et les cibles d'augmentation sont ce que les gens capitalisent, et la couleur suit les gens.

**`Some`, `None`, `Ok` et `Err` sont des types, pas des constantes.** Ce sont les variantes d'unions ordinaires déclarées dans `gololang.Errors`, disponibles après un `import`, pas des builtins.

**`DynamicObject` est un builtin, majuscule comprise.** Il est dans la table de l'interpréteur, et la table l'emporte sur la règle de casse.

**Les noms peuvent contenir toute lettre Unicode, et des emoji.** Le `isLetter` du lexer admet les lettres, les marques, `_` et quatre blocs d'emoji (émoticônes, symboles et pictogrammes divers, symboles de transport et de cartes, symboles et pictogrammes supplémentaires) ; le scanner applique la même règle.

**La coloration suit le lexer, pas le parseur.** Le parseur de GoloScript, en v0.1.1, refuse plusieurs tokens que son lexer lit : les suffixes `L`, `F` et `f`, un littéral de caractère `'c'`, l'intervalle `..`, `orIfNull`, `oftype` et `local function`. Ils sont colorés comme le lexer les lit, et le serveur de langage marque la ligne quand le parseur les refuse. `demos/syntax-tour/lexer-only.golo` en contient un de chaque.

**Non reconnu**, chacun pour une raison énoncée :

| Non reconnu | Parce que |
| --- | --- |
| `1_000` comme un seul nombre | Le lexer n'a pas de séparateur de chiffres : `_` commence un nom, c'est donc `1` puis `_000` |
| `0xFF`, `0b1010`, `0o17` comme nombres | Le lexer n'a pas de préfixe de base : `0xFF` est `0` puis le nom `xFF` |
| `.5` comme nombre | Le lexer exige un chiffre avant le point, c'est donc un point puis `5` |
| `42l` comme long | Le lexer n'accepte que le `L` majuscule, c'est donc `42` et le nom `l` |
| `---` comme commentaire | Quatre tirets ouvrent un commentaire bloc ; trois sont une suite d'opérateurs |
| Un mot-clé après `:` comme nom de méthode | `obj: match()` garde `match` en mot-clé — le scanner ne suit pas ce qu'un deux-points introduit |
| Un échappement dans `"""…"""` | Le lexer ajoute chaque rune jusqu'aux trois guillemets, `"""a\"""` se termine donc à son premier `"""` |
| Un constructeur autrement que comme un type | Rien dans la syntaxe ne sépare `Circle(1.0)` d'un type appliqué à des arguments |
| Une chaîne non terminée qui s'arrête à sa ligne | L'interpréteur lit jusqu'au guillemet fermant où qu'il soit, la couleur le suit donc — l'inverse de la décision de Turbo MoonBit, pour la raison inverse |
| Si un nom est lié dans cette portée | Rien ici ne lit plus d'une ligne à la fois ; c'est la question du serveur de langage, et [F1 y répond](../how-to/ask-about-code.md) |

## TOML

| Reconnu | Comme |
| --- | --- |
| `# commentaire` | commentaire |
| `[table]`, `[[tableau]]` | le nom comme type, les crochets comme ponctuation |
| `clé =` | identifiant, puis opérateur |
| `"basique"`, `'littérale'`, `"""multiligne"""`, `'''multiligne'''` | chaîne |
| `true`, `false` | constante |
| nombres, dates, heures, `inf`, `nan` | nombre |

## YAML

Un fichier compose, un manifeste Kubernetes et un workflow de CI sont tous cela : il n'y a pas de dialecte séparé, parce qu'un dialecte serait le schéma de quelqu'un d'autre à maintenir en phase.

| Reconnu | Comme |
| --- | --- |
| `# commentaire` | commentaire |
| `clé:` avant un espace ou la fin de ligne | la clé comme identifiant, le deux-points comme ponctuation |
| `"citée": 1`, `'citée': 1` | la clé citée comme identifiant |
| `- ` ouvrant un élément de séquence | ponctuation |
| `"…"`, `'…'` | chaîne |
| `true`, `false`, `yes`, `no`, `on`, `off`, `null` | constante, quelle que soit la casse |
| nombres, dates et heures écrits sans guillemets | nombre |
| `&ancre`, `*alias` | builtin |
| `!!str`, `!Custom` | type |
| `---`, `...` | toute la ligne comme ponctuation |
| `{`, `}`, `[`, `]`, `,` | ponctuation |
| `\|`, `>`, avec leurs indicateurs de troncature et d'indentation | l'en-tête comme opérateur, le corps comme chaîne |

**Un deux-points n'est un séparateur que si un espace ou la fin de ligne le suit.** `image: nginx:1.27` est une clé et une valeur, et `url: http://example.com/x` est une clé et une URL — colorer les deux-points intérieurs comme séparateurs mettrait chaque tag d'image et chaque URL en trois couleurs.

**L'étendue d'un scalaire bloc est décidée par l'indentation**, pas par un délimiteur. La première ligne de contenu après `|` ou `>` fixe l'indentation du bloc ; chaque ligne indentée au moins autant lui appartient, et la première qui ne l'est pas le termine. **Une ligne vide dans un bloc reste dans le bloc** : un scalaire littéral garde ses lignes vides, et terminer le bloc au premier saut de paragraphe couperait en deux un script shell dans un fichier de CI.

**Un `#` a besoin d'un espace devant pour ouvrir un commentaire**, `colour: ff#00aa` est donc un seul scalaire.

| Non reconnu | Parce que |
| --- | --- |
| Le schéma d'un fichier compose, d'un manifeste ou d'un workflow | Colorer `services:` autrement que n'importe quelle clé signifie porter le schéma de quelqu'un d'autre, et il vieillit le jour où ils ajoutent une clé |
| Les flux multi-documents comme documents séparés | `---` est coloré, mais rien n'est réinitialisé ; rien dans la coloration ne dépend des frontières de documents |
| Si un mot nu est une chaîne ou un nombre pour un parseur | `1.2.3` est une version pour un lecteur et une chaîne pour YAML ; le scanner colore ce à quoi cela ressemble |

## Markdown

| Reconnu | Comme |
| --- | --- |
| `# Titre` … `###### Titre` | toute la ligne comme titre |
| `**gras**`, `__gras__`, `*italique*`, `_italique_` | emphase |
| `` `code` `` | chaîne |
| `[texte](cible)`, `![alt](src)` | le tout comme lien |
| `- `, `* `, `+ `, `1. `, `1) ` | le marqueur comme ponctuation |
| `>` | ponctuation |
| `---`, `***`, `___` | ponctuation |
| les clôtures ` ``` ` et `~~~` | tout le bloc, lignes d'ouverture et de fermeture comprises, comme chaîne |

Un bloc clôturé est **d'une seule couleur quel que soit le langage annoncé** : ```` ```golo ```` ne colore pas son contenu comme du Golo. La suite de marqueurs qui ouvre un bloc doit être fermée par le même caractère, une clôture en accents graves n'est donc pas fermée par une en tildes. Une clôture non fermée colore jusqu'à la fin du fichier.

La suite de marqueurs ouvrant une emphase doit être fermée par une suite de même longueur, `**gras**` est donc une portée plutôt que deux italiques.

## JavaScript

| Reconnu | Comme |
| --- | --- |
| `const`, `let`, `function`, `class`, `async`, `await`, `import`, `export`, … | mot-clé |
| `true`, `false`, `null`, `undefined`, `NaN`, `Infinity`, `this` | constante |
| `console`, `document`, `window`, `Array`, `Object`, `Promise`, `Math`, `JSON`, … | builtin |
| un nom immédiatement avant `(` | fonction |
| `"…"`, `'…'` | chaîne |
| `` `…` ``, interpolations comprises, sur plusieurs lignes | chaîne |
| `//` jusqu'à la fin de ligne, `/* … */` sur plusieurs lignes | commentaire |
| `42`, `3.14`, `0x1f`, `0b1010`, `0o777`, `1_000_000`, `1e6`, `10n` | nombre |
| les suites de `+-*/%=<>!&|^~?:` | opérateur |
| `()[]{},;.` | ponctuation |

**Les littéraux d'expressions régulières ne sont pas reconnus.** Distinguer `/x/g` d'une division demande de savoir si le token précédent pouvait terminer une expression ; une mauvaise supposition colore le reste d'une ligne comme une chaîne, ce qui est pire que de laisser une regex de la couleur d'un opérateur.

Les globales sont reconnues par leur nom, un fichier qui masque `Math` le voit donc toujours coloré comme builtin — la même règle que suivent ici les builtins de Golo.

## HTML

| Reconnu | Comme |
| --- | --- |
| `<tag`, `</tag`, `>`, `/>` | balise |
| les noms d'attributs, dont `data-*`, `xlink:href`, `@click`, `v-bind.prop` | attribut |
| `=` | opérateur |
| `"…"`, `'…'` | chaîne |
| `<!-- … -->`, sur plusieurs lignes | commentaire |
| `&amp;`, `&#169;` | constante |
| `<!DOCTYPE …>` et les autres déclarations | mot-clé |

Le texte entre les balises n'est pas coloré. Un `&` nu sans `;` dans les 32 caractères est laissé tranquille, parce que c'est du texte légal.

**Le contenu de `<script>` et `<style>` n'est pas coloré** comme du JavaScript et du CSS.

## XML

Son propre scanner plutôt que celui de HTML, pour une raison qui compte : CDATA. Tout l'intérêt de `<![CDATA[ … ]]>` est que son contenu n'est *pas* du balisage, et colorer les balises qu'il contient comme des balises est exactement à l'envers.

| Reconnu | Comme |
| --- | --- |
| `<?xml version="1.0"?>` et les autres instructions de traitement | la cible et `?>` comme mot-clé, les paires entre elles comme attributs et chaînes |
| `<!DOCTYPE …>` et les autres formes `<!` | mot-clé |
| `<!-- … -->`, sur plusieurs lignes | commentaire |
| `<![CDATA[ … ]]>`, sur plusieurs lignes | chaîne |
| `<tag`, `</tag`, `>`, `/>` | balise |
| `<ns:tag>`, `xsi:type` | le préfixe et le nom local en **une** portée |
| les noms d'attributs | attribut |
| `=` | opérateur |
| `"…"`, `'…'` | chaîne |
| `&amp;`, `&#169;` | constante |

**Un commentaire et une section CDATA se ferment sur des délimiteurs différents**, et sont portés séparément : un `-->` dans une section CDATA ne la termine pas.

**Un `&` nu sans point-virgule dans les 32 caractères est laissé tranquille**, parce que c'est du texte légal dans bien des documents et qu'avaler le reste de la ligne serait la plus grosse erreur.

Le texte entre les balises n'est pas coloré.

## Shell

Vaut pour `sh`, `bash` et `zsh` : les mots-clés reconnus sont ceux qu'ils partagent.

| Reconnu | Comme |
| --- | --- |
| `if`, `then`, `fi`, `for`, `while`, `case`, `esac`, `function`, `return`, … | mot-clé |
| `true`, `false` | constante |
| `echo`, `printf`, `export`, `local`, `read`, `cd`, `set`, `source`, … | builtin |
| `$NAME`, `${…}`, `$(…)`, `$1`, `$?`, `$@` | builtin |
| le **premier mot nu d'une ligne** | fonction |
| chaque mot nu suivant, et `NAME` dans `NAME=valeur` | identifiant |
| `'…'`, sans rien d'échappé ni de développé dedans | chaîne |
| `"…"`, avec les expansions dedans colorées comme des expansions | chaîne |
| `#` jusqu'à la fin de ligne | commentaire |

`$(a $(b) c)` est une seule portée : l'imbrication est comptée. Une option comme `-euo` est un seul mot, pas un moins et un mot.

**Les heredocs ne sont pas reconnus.** `<<EOF` et le texte qui suit sont colorés comme du shell ordinaire.

## Dockerfile

| Reconnu | Comme |
| --- | --- |
| `FROM`, `RUN`, `COPY`, `ADD`, `ARG`, `ENV`, `CMD`, `ENTRYPOINT`, `EXPOSE`, `LABEL`, `USER`, `VOLUME`, `WORKDIR`, `HEALTHCHECK`, `ONBUILD`, `SHELL`, `STOPSIGNAL`, `MAINTAINER` | mot-clé, quelle que soit la casse |
| `AS`, `NONE` | mot-clé |
| `# commentaire`, y compris les directives `# syntax=` et `# escape=` | commentaire |
| `--from=builder`, `--chown=me:me` | le nom de l'option comme attribut |
| `$NAME`, `${NAME}`, `${NAME:-default}` | builtin, en une portée jusqu'à l'accolade fermante |
| `"…"`, `'…'` | chaîne |
| un `\` final | opérateur |
| les nombres | nombre |
| les chemins et références d'images — `/usr/local/bin`, `golang:1.26-alpine` | identifiant, en **une** portée |

**Seul le premier mot d'une ligne peut être une instruction**, et un mot qui n'en est pas une est un argument — ce qui garde le premier mot d'une ligne de continuation hors de la couleur des mots-clés.

**Rien ne franchit une ligne.** Un `\` joint deux lignes pour Docker, mais chaque moitié se lit toujours comme une commande et est colorée seule.

| Non reconnu | Parce que |
| --- | --- |
| Le shell dans un `RUN` | Il faudrait lancer le scanner shell sur une partie de ligne et reporter ses colonnes, et `RUN` peut contenir n'importe quel langage |
| Les heredocs dans un `RUN` | La même raison que pour le scanner shell |
| Quelle étape un `--from` nomme | Rien ici ne lit le reste du fichier |

## Voir aussi

- [Format des fichiers de thème](themes.md) — chaque clé vers laquelle ces classes résolvent
- [Coloration et complétion](../explanation/colouring-and-completion.md) — pourquoi les scanners sont écrits ainsi
- [Écrire son propre thème](../how-to/write-a-theme.md)