# Werken met syntaxisaccentuering

## Overzicht

Accentuering van syntaxis zorgt er voor dat de tekstbewerker automatisch tekst in verschillende stijlen/kleuren laat zien, afhankelijk van de functie van de tekenreeks in relatie tot het doel van het bestand. In broncode voor programma's bijvoorbeeld, kunnen besturingsstatements vet worden weergegeven, terwijl typen gegevens en commentaar een andere kleur krijgen dan de rest van de tekst. Dit verbetert de leesbaarheid van de tekst enorm en helpt de auteur dus om efficiënter en productiever te zijn.

Een Perl-functie, weergegeven met syntaxisaccentuering.

Een Perl-functie, weergegeven met syntaxisaccentuering.

Dezelfde Perl-functie, weergegeven zonder accentuering.

Dezelfde Perl-functie, weergegeven zonder accentuering.

Welke van de twee voorbeelden is gemakkelijker te lezen?

&kappname; komt met een flexibel, te configureren en capabel systeem voor accentuering van de syntaxis en de standaard distributie levert definities voor een brede reeks van programmeer-, script- en markup-talen en andere formaten van tekstbestanden. Bovendien kunt u uw eigen definities leveren in eenvoudige &XML;-bestanden.

&kappname; zal automatisch de juiste syntaxisregels detecteren wanneer u een bestand opent, gebaseerd op het &MIME;-type van het bestand, bepaald door zijn extensie of, als deze er geen heeft, de inhoud. Ervaart u een foute keuze, dan kunt u handmatig de te gebruiken syntaxis instellen uit het menu Hulpmiddelen Accentuering.

De stijlen en kleuren die door elke definitie voor syntaxisaccentuering kan worden ingesteld met het tabblad Accentuering van tekststijlen van de Instellingendialoog, terwijl de &MIME;-types en bestandsextensies waarvoor ze gebruikt zouden moeten worden, worden behandeld door het tabblad Modi & bestandstypen.

Syntaxisaccentuering is er om de leesbaarheid van correcte tekst te verhogen, maar u kunt het niet vertrouwen om uw tekst te valideren. Tekst markeren voor syntaxis is moeilijk, afhankelijk van het formaat dat u gebruikt en in sommige gevallen zullen de auteurs van de syntaxisregels trots zijn als 98% van de tekst juist wordt weergegeven, hoewel u meestal een zeldzame stijl nodig hebt om de onjuiste 2% tegen te komen.

U kunt bijgewerkte of extra definities voor syntaxisaccentuering downloaden van de &kappname;-website door op de knop Accentueringsbestanden downloaden... te klikken in het tabblad Modi & bestandstypen van de Instellingendialoog.

## Het systeem voor syntaxisaccentuering van &kappname;

Deze sectie zal het mechanisme voor syntaxisaccentuering van &kappname; in meer detail laten zien. Het is er voor u als u er iets over wilt weten of als u syntaxis-definities wilt veranderen of aanmaken.

### Hoe het werkt

Wanneer u een bestand opent, is een van de eerste dingen die de tekstbewerker &kappname; doet, het detecteren van welke syntaxis-definitie voor het bestand moet worden gebruikt. Terwijl de tekst van het bestand wordt ingelezen en terwijl u het intypt, zal het systeem voor syntaxisaccentuering de tekst analyseren met de regels gedefinieerd door de syntaxis-definitie en het markeren waar verschillende contexten en stijlen beginnen en eindigen.

Tijdens het typen van het document wordt de nieuwe tekst geanalyseerd en direct gemarkeerd, zodat wanneer u een teken verwijdert die is gemarkeerd als het begin van einde van een context, de stijl van de tekst er omheen overeenkomstig wijzigt.

De syntaxis-definities die door het systeem voor syntaxisaccentuering van &kappname; wordt gebruikt zijn &XML;-bestanden, bevattende

- Regels voor detecteren van de rol van tekst, georganiseerd in contextblokken

- Lijsten met sleutelwoorden

- Definities van stijl-items

Bij het analyseren van de tekst worden de detectieregels geëvalueerd in de volgorde waarin ze zijn gedefinieerd en, als het begin van de huidige tekenreeks overeenkomt met een regel, wordt de gerelateerde context gebruikt. Het beginpunt in de tekst wordt verplaatst naar het eindpunt waarop die regel overeenkomt en een nieuwe ronde van de regels begint, beginnend in de context ingesteld door de overeenkomende regel.

### Regels

De detectieregels zijn het hart van het detectiesysteem voor accentuering. Een regel is een tekenreeks, teken of reguliere expressie waartegen de tekst die wordt geanalyseerd wordt vergeleken. Het bevat informatie over welke stijl te gebruiken voor het overeenkomende deel van de tekst. Het kan de in werking zijnde context van het system omschakelen ofwel naar een expliciet genoemde context of naar de vorige context in gebruik bij de tekst.

Regels zijn georganiseerd in contextgroepen. Een contextgroep wordt gebruikt voor hoofdtekstconcepten in het formaat, bijvoorbeeld tekenreeksen tussen aanhalingstekens of commentaarblokken in broncode van programma's. Dit zorgt ervoor dat het accentueringssysteem niet door alle regels hoeft te doorlopen wanneer het niet noodzakelijk is en dat sommige tekenreeksen in de tekst anders kan worden behandeld afhankelijk van de huidige context.

Contexts kunnen dynamisch worden gegenereerd om het gebruik van specifieke gegevens bij toestanden in regels toe te staan.

### Contextstijlen en sleutelwoorden

In sommige programmeertalen worden door de compiler (het programma dat de broncode vertaald in een binair uitvoerbaar programma) gehele getallen anders behandeld dan drijvendekommagetallen en er kunnen tekens zijn met een speciale betekenis in een tekenreeks tussen aanhalingsteken. In zulke gevallen, is het zinvol om ze verschillend weer te geven in hun omgeving zodat ze gemakkelijk zijn te identificeren bij het lezen van de tekst. Dus zelfs als ze speciale contexts representeren, kunnen ze als zodanig door het systeem voor accentuering van syntaxis worden gezien, zodat ze gemarkeerd kunnen worden voor een anders weergeven.

Een syntaxis-definitie kan zoveel stijlen bevatten als nodig is om de concepten van het formaat te dekken waarvoor het wordt gebruikt.

In vele formaten zijn er lijsten woorden die een specifiek concept representeren. Bijvoorbeeld in programmeertalen, zijn controlstatements een concept, namen van gegevenstypen een andere en ingebouwde functies van de taal een derde. Het accentueringssysteem voor syntaxis van &kappname; kan zulke lijsten gebruiken om woorden in de tekst te detecteren en te markeren om concepten te accentueren van de tekstformaten.

### Standaard stijlen

Als u in &kappname; een C++ bronbestand, een &Java; bronbestand en een HTML document opent, dan zult u zien dat zelfs wanneer de formaten verschillend zijn en dus verschillende woorden voor een speciale behandeling worden gekozen, de gebruikte kleuren hetzelfde zijn. Dit komt omdat &kappname; een voorgedefinieerde lijst met standaard stijlen heeft die worden gebruikt bij de individuele definities van syntaxis.

Dit maakt het gemakkelijk om gelijkvormige concepten in verschillende tekstformaten te herkennen. Bijvoorbeeld: commentaar is in bijna elk programma, script of markup-language aanwezig en wanneer ze in alle talen op dezelfde manier worden weergegeven, dan hoeft u niet meer na te denken om ze in de tekst te herkennen.

Alle stijlen in een syntaxisdefinitie gebruiken een van de standaard stijlen. Een paar syntaxisdefinities gebruiken meer stijlen dan er standaarden zijn, dus als u een format vaak gebruikt kan het het waard zijn om de instellingendialoog te starten om te zien of sommige concepten dezelfde stijl gebruiken. Er is bijvoorbeeld slechts één standaard stijl voor tekenreeksen, maar de Perl programmeertaal werkt met twee typen tekenreeksen, u kunt het accentueren verbeteren door ze enigszins verschillend in te stellen. Alle beschikbare standaard stijlen zullen later worden verklaard.

## Het &XML;-formaat voor definitie van accentuering

### Overzicht

Deze sectie is een overzicht van het formaat van 'Highlight Definition &XML;'. Het zal de hoofdcomponenten, hun betekenis en gebruik beschrijven op basis van een klein voorbeeld. De volgende sectie zal in detail de accentueringdetectieregels uitleggen.

De formele definitie, ook bekend als, de DTD wordt opgeslagen in het bestand `language.dtd` die op uw systeem geïnstalleerd zou moeten zijn in de map `$`KDEDIR`/share/apps/katepart/syntax`.

### Hoofdsecties van bestanden voor accentueringsdefinities van &kappname;

Een bestand voor accentuering bevat een kop die de XML-versie en het doctype instelt:

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

De basis van het definitiebestand is het element `language`. Beschikbare attributen zijn:

- Vereiste attributen:

  `name` stelt de naam van de taal in. Het verschijnt nadien in de menu's en dialogen.

  `section` specificeert de categorie.

  `extensions` definieert bestandsextensies, zoals "*.cpp;*.h"

  Optionele attributen:

  `mimetype` associeert ket &MIME;-type van bestanden.

  `version` specificeert de huidige versie van het definitiebestand.

  `kateversion` specificeert de laatst ondersteunde versie van &kappname;.

  `casesensitive` definieert of de sleutelwoorden gevoelig zijn voor hoofd- en kleine letters.

  `priority` is nodig als een andere bestand met accentueringsdefinities dezelfde extensies gebruiken. De hogere prioriteit wint.

  `author` bevat de naam van de auteur en zijn/haar e-mailadres.

  `license` bevat de licentie, gewoonlijk LGPL, Artistic, GPL of andere.

  `hidden` definieert of de naam moet verschijnen in de menu's van &kappname;.

  De volgende regel kan er als volgt uitzien:

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

Vervolgens komt het element `highlighting`, die het optionele element `list` bevat en de vereiste elementen `contexts` en `itemDatas`.

- Elementen `list` bevatten een lijst met sleutelwoorden. In dit geval zijn de sleutelwoorden class en const. U mag zoveel elementen 'list' toevoegen als nodig is.

  Het element `contexts` bevat alle contexten. De eerste context is per definitie het begin van de accentuering. Er zijn twee regels in de context Normal Text, die overeenkomt met de lijst sleutelwoorden met de naam somename en een regel die een aanhalingsteken detecteert en de context om schakelt naar String. Om meer over regels te leren, leest u het volgende hoofdstuk.

  Het derde deel is het element `itemDatas`. Het bevat alle kleur- en lettertypestijlen nodig voor de contexten en regels. In dit voorbeeld worden `itemData` Normal Text, String en Keyword gebruikt.

      <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>

Het laatste deel van een accentueringsdefinitie is de optionele sectie `general`. Het mag informatie over sleutelwoorden, vouwen van code, commentaar en inspringen bevatten.

- De sectie `comment` definieert met welke tekenreeks een enkele regel commentaar wordt aangegeven. U kunt ook commentaar op meerdere regels definiëren met multiLine met het additionele attribuut end. Dit wordt gebruikt als de gebruiker op de bijbehorende sneltoets voor comment/uncomment drukt.

  De sectie `keywords` definieert of lijsten met sleutelwoorden onderscheid maken tussen hoofd- en kleine letters. Andere attributen zullen later worden verklaard.

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

### De secties in detail

Dit deel zal alle beschikbare attributen voor contexten beschrijven, itemDatas, sleutelwoorden, commentaar, code opvouwen en inspringen.

Het element `context` behoort tot de groep `contexts`. Een context zelf definieert context specifieke regels zoals wat zou moeten gebeuren als het systeem voor accentuering het eind van een regel bereikt. Beschikbare attributen zijn:

- `name` geeft de contextnaam aan. Regels zullen deze naam gebruiken om de context te specificeren om om te schakelen als de regel overeenkomt.

  `lineEndContext` definieert de context waarnaar het systeem voor accentuering omschakelt als het einde van een regel wordt bereikt. Dit kan of de naam van een andere context zijn, `#stay` om de context niet om te schakelen (⪚. niets doen) of `#pop` wat de oorzaak is van het verlaten van deze context. Het is mogelijk om bijvoorbeeld `#pop#pop#pop` te gebruiken om drie keer te poppen of zelfs `#pop#pop!AndereContext` om twee keer te poppen en om te schakelen naar de context genaamd `AndereContext`.

  `lineEmptyContext` definieert de context als een lege regel wordt bereikt. Standaard: #stay.

  `fallthrough` definieert of het systeem voor accentuering omschakelt naar de context gespecificeerd in fallthroughContext als er geen regel overeenkomt. Standaard: false.

  `fallthroughContext` specificeert de volgende context als geen regel overeenkomt.

  `dynamic` indien true, dan herinnert de context tekenreeksen/plaatshouders opgeslagen door dynamische regels. Dit is bijvoorbeeld nodig voor HIER-documenten. Standaard: false.

Het element `itemData` is in de groep `itemDatas`. Het definieert de lettertypestijl en kleuren. Het is dus mogelijk om uw eigen stijlen en kleuren te definiëren. Wij bevelen echter aan om, indien mogelijk, bij de standaard stijlen te blijven zodat de gebruiker altijd dezelfde zal zien in verschillende talen. Soms is er echter geen andere manier en is het noodzakelijk de kleur- en lettertypeattributen te wijzigen. De attributen naam en defStyleNum zijn vereist, de anderen zijn optioneel. Beschikbare attributen zijn:

- `name` stelt de naam van het itemData in. Contexten en regels zullen deze naam in hun attribuut attribute gebruiken om naar een itemData te verwijzen.

  `defStyleNum` definieert welke standaard stijl te gebruiken. Beschikbare standaard stijlen worden later in detail verklaard.

  `color` definieert een kleur. Geldige formaten zijn '#rrggbb' of '#rgb'.

  `selColor` definieert de selectiekleur.

  `italic` indien true, de tekst zal cursief worden.

  `bold` indien true, de tekst zal vet worden.

  `underline` indien true, de tekst zal onderstreept worden.

  `strikeout` indien true, door de tekst zal een streep worden gezet.

  `spellChecking` indien true, de tekst zal gecontroleerd worden op spelling.

Het element `keywords` in de groep `general` definieert sleutelwoordeigenschappen. Beschikbare attributen zijn:

- `casesensitive` mag true of false zijn. Indien true, worden alle sleutelwoorden met onderscheid tussen hoofd- en kleine letters met elkaar vergeleken

  `weakDeliminator` is een lijst met tekens die niet als scheiding tussen woorden werken. Bijvoorbeeld: de punt `'.'` is een scheider van woorden. Als een sleutelwoord in een `list` een punt bevat, dan zal die alleen overeenkomen als u de punt als een zwak scheidingsteken specificeert.

  `additionalDeliminator` definieert extra scheidingstekens.

  `wordWrapDeliminator` definieert tekens waarna een regel mag afbreken.

  Standaard scheidingstekens en regelafbreektekens zijn de tekens `.():!+,-<=>%&*/;?[]^{|}~\`, spatie (`' '`) en tab (`'\t'`).

Het element `comment` in de groep `comments` definieert eigenschappen van commentaar die gebruikt worden voor Hulpmiddelen Commentaar en Hulpmiddelen Commentaar verwijderen. Beschikbare attributen zijn:

- `name` is either singleLine or multiLine. If you choose multiLine the attributes end and region are required.

  `start` definieert de gebruikte tekenreeks om commentaar te laten beginnen. In C++ zou dit "/*" zijn.

  `end` definieert de gebruikte tekenreeks om commentaar te laten eindigen. In C++ zou dit "*/" zijn.

  `region` moet de naam van het opvouwbare multiregel commentaar. U hebt beginRegion="Comment" ... endRegion="Comment" in uw regels, u zou region="Comment" moeten gebruiken. Op deze manier werkt verwijderen zelfs als u niet alle tekst van het multiregel commentaar selecteert. De cursor hoeft alleen in het multiregel commentaar te staan.

Het element `folding` in de groep `general` definieert de eigenschappen van het invouwen van broncode. Beschikbare attributen zijn:

- De markeringen voor code opvouwen, als `indentationsensitive` true is, zullen worden toegevoegd gebaseerd op inspringen, zoals in de scripttaal Python. Het is gewoonlijk niet nodig dit in te stellen omdat de standaard false is.

Het element `indentation` in de groep `general` definieert welke inspringing gebruikt zal worden. We bevelen ten zeerste aan om dit element over te slaan, omdat de inspringing gewoonlijk ingesteld zal worden door ofwel een Bestandstype of door een modusregel toe te voegen aan het tekstbestand. Als u toch een inspringing definieert, forceert u een specifieke inspringing op de gebruiker, die hij helemaal niet wil. Beschikbare attributen zijn:

- `mode` is de naam van de inspringing. Beschikbare inspringingen op dit moment zijn: normal, cstyle, haskell, lilypond, lisp, python, ruby en xml.

### Beschikbare standaard stijlen

Standaard stijlen zijn al verklaard, als een korte samenvatting: Standaard stijlen zijn voorgedefinieerde lettertypen- en kleurstijlen.

Dus is hier is alleen de lijst met beschikbare standaard stijlen:

- `dsNormal`, gebruikt voor normale tekst.

  `dsKeyword`, gebruikt voor trefwoorden.

  `dsDataType`, gebruikt voor gegevenstypen.

  `dsDecVal`, wordt gebruikt voor decimale waarden.

  `dsBaseN`, wordt gebruikt voor waarden met een andere basis dan 10.

  `dsFloat`, wordt gebruikt voor drijvende-komma waarden.

  `dsChar`, wordt gebruikt voor een teken.

  `dsString`, wordt gebruikt voor tekenreeksen.

  `dsComment`, wordt gebruikt voor commentaar.

  `dsOthers`, wordt gebruikt voor 'andere' dingen.

  `dsAlert`, wordt gebruikt voor waarschuwingsberichten.

  `dsFunction`, wordt gebruikt voor functie-aanroepen.

  `dsRegionMarker`, wordt gebruikt voor gebiedmarkeringen.

  `dsError`, wordt gebruikt voor accentuering van fouten en foute syntaxis.

## Detectieregels accentueren

Deze paragraaf beschrijft de syntaxis van detectieregels.

Elke regel kan nul of meer tekens aan het begin van de tekenreeks bevatten, waartegen ze worden getest. Als de regel overeenkomt worden de overeenkomstige tekens toegekend aan de stijl of attribuut gedefinieerd door de regel en een regel kan vragen de huidige context om te schakelen.

Een regel ziet er als volgt uit:

    <RuleName attribute="(identifier)" context="(identifier)" [regelspecifieke attributen] />

Het attribute identificeert de te gebruiken stijl voor overeenkomende tekens bij naam en de context identificeert de vanaf hier te gebruiken context.

De context kan worden geïdentificeerd door:

- Een identifier, wat de naam is van de andere context.

- Een opdracht die de engine vertelt om in de huidige context te blijven (`#stay`) of terug te gaan naar een eerdere context met in de tekenreeks (`#pop`).

  Om meer stappen terug te gaan kan het #pop commando worden herhaald: `#pop#pop#pop`

- Een order gevolgd door een uitroepteken (!) en een identifier, die er voor zorgt dat de engine eerst de order volgt en dan omschakelt naar de andere context, bijv. `#pop#pop!AndereContext`.

Sommige regels kunnen dochterregels hebben die dan alleen worden geëvalueerd als de ouderregel overeenkomt. De gehele overeenkomende tekenreeks zal het attribuut worden gegeven die is gedefinieerd door de ouderregel. Een regel met dochterregels ziet er als volgt uit:

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

Specifieke attributen van regels variëren en zijn beschreven in de volgende secties.

## Gezamenlijke attributen

Alle regels hebben de volgende gezamenlijke attributen en zijn beschikbaar wanneer `(common attributes)` verschijnt. attribute en context zijn vereiste attributen, alle andere zijn optioneel.

- attribute: Een attribuut komt overeen met een gedefinieerd itemData.

- context: Specificeer de context waarnaar het accentueringssysteem omschakelt als de regel overeenkomt.

- beginRegion: Start een invouwblok voor code. Standaard: niet ingesteld.

- endRegion: Sluit een invouwblok voor code. Standaard: niet ingesteld.

- lookAhead: Indien true, zal het accentueringssysteem niet de overeenkomende lengte verwerken. Standaard: false.

- firstNonSpace: Komt alleen overeen als de tekenreeks de eerste niet-witruimte in de regel. Standaard: false.

- column: Komt alleen overeen als de kolom overeenkomt. Standaard: niet ingesteld.

## Dynamische regels

Sommige regels staan het optionele attribuut `dynamic` toe van het type boolean dat standaard de waarde false heeft. Als dynamic true is kan een regel plaatshouders bevatten die de tekst representeren die overeenkomt met een reguliere expressie die schakelt naar de huidige context in zijn attributen `tekenreeks` of `teken`. In een `tekenreeks`wordt de plaatshouder `%N` (waar N is a getal is) vervangen door de overeenkomstige vangst `N` uit de aanroepende reguliere expressie. In een `teken` moet de plaatshouder een getal `N` zijn en het zal worden vervangen door het eerste teken van de overeenkomstige vangst `N` uit de aanroepende reguliere expressie. Wanneer een regel dit attribuut toestaat zal het een (dynamic) bevatten.

- dynamic: kan (true|false) zijn.

### De regels in detail

DetectChar

- Detecteert een enkele specifiek teken. Gewoonlijk gebruikt, bijvoorbeeld om het einde van een tekenreeks tussen accenten of aanhalingstekens.

      <DetectChar char="(teken)" (common attributes) (dynamic) />

  Het attribuut `char` definieert het teken dat moet overeenkomen.

Detect2Chars

- Detecteert twee specifieke tekens in een gedefinieerde volgorde.

      <Detect2Chars char="(teken)" char1="(teken)" (common attributes) (dynamic) />

  Het attribuut `char` definieert het eerste teken dat moet overeenkomen, `char1` the tweede.

AnyChar

- Detecteer één teken van een set van gespecificeerde tekens.

      <AnyChar String="(tekenreeks)" (common attributes) />

  Het attribuut `String` definieert de set tekens.

StringDetect

- Detecteert een exacte tekenreeks.

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

  Het attribuut `String` definieert de overeen te komen tekenreeks. Het attribuut `insensitive` is standaard false en wordt doorgegeven aan de vergelijkingsfunctie van de tekenreeks. Als de waarde true is wordt 'insensitive' vergelijking gebruikt.

WordDetect

- Detecteert een exacte tekenreeks maar vereist extra woordgrenzen zoals een punt `'.'` of witruimte aan het begin en eind van het woord. Denk aan `\b<tekenreeks>\b` in termen van een reguliere expressie, het is echter sneller dan de regel `RegExpr`.

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

  Het attribuut `String` definieert de overeen te komen tekenreeks. Het attribuut `insensitive` is standaard false en wordt doorgegeven aan de vergelijkingsfunctie van de tekenreeks. Als de waarde true is wordt 'insensitive' vergelijking gebruikt.

  Sinds: &kate; 3.5 (&kde; 4.5)

RegExpr

- Komt overeen met een reguliere expressie.

      <RegExpr String="(tekenreeks)" [insensitive="true|false"] [minimal="true|false"] (common attributes) (dynamic) />

  Het attribuut `String` definieert de reguliere expressie.

  `insensitive` is standaard false en wordt doorgegeven aan de engine voor de reguliere expressie.

  `minimal` is standaard false en wordt doorgegeven aan de engine voor de reguliere expressie.

  Omdat de regels altijd vergeleken worden met het begin van de huidige tekenreeks, zal een reguliere expressie die begint met een dakje (`^`) aangeven dat de regel alleen overeen moet komen met het begin van een regel.

  Zie Reguliere expressies voor meer informatie hierover.

trefwoord

- Detecteert een sleutelwoord uit een gespecificeerde lijst.

      <keyword String="(lijstnaam)" (common attributes) />

  Het attribuut `String` identificeert de lijst met sleutelwoorden met een naam. Een lijst met die naam moet bestaan.

  Het systeem voor accentuering bewerkt sleutelwoordregels op een zeer geoptimaliseerde manier. Dit maakt het absoluut noodzakelijk dat elk te vinden sleutelwoord omgeven wordt door gedefinieerde scheidingstekens, ofwel impliciet (de standaard scheidingstekens) of expliciet gespecificeerd binnen de eigenschap additionalDeliminator van de sleutelwoord-tag.

  Als een te vinden sleutelwoord een scheidingsteken moet bevatten, dan moet dit teken toegevoegd worden aan de eigenschap weakDeliminator van de sleutelwoord-tag. Dit teken zal dan zijn eigenschap scheidingsteken in alle sleutelwoord-regels verliezen.

Int

- Detecteert een geheel getal.

      <Int (common attributes) (dynamic) />

  Deze regel heeft geen specifieke attributen. Dochterregels worden typisch gebruikt om combinaties met `L` en `U` na het getal te detecteren, die het type geheel getal in programmacode aangeeft. Alle dochterregels zijn toegestaan als dochterregels, hoewel de DTD alleen de dochterregel `StringDetect` toestaat.

  Het volgende voorbeeld laat overeenkomst zien met gehele getallen gevolgd door het teken 'L'.

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

Drijvende komma

- Een drijvende kommagetal detecteren.

      <Drijvende komma (algemene attributen) />

  Deze regel heeft geen specifieke attributen. `AnyChar` is toegestaan als een dochterregel en wordt typisch gebruikt om combinaties te detecteren, zie de regel `Int` als referentie.

HlCOct

- Detecteert de representatie van een octaal puntgetal.

      <HlCOct (common attributes) />

  Deze regel heeft geen specifieke attributen.

HlCHex

- Detecteert de representatie van een hexadecimaal getal.

      <HlCHex (common attributes) />

  Deze regel heeft geen specifieke attributen.

HlCStringChar

- Detecteer een escaped teken.

      <HlCStringChar (common attributes) />

  Deze regel heeft geen specifieke attributen.

  Komt overeen met de letterlijke representatie van tekens, gewoonlijk gebruikt in programmacode, bijvoorbeeld `\n` (nieuwe-regel) of `\t` (TAB).

  De volgende tekens zullen overeenkomen als ze volgen op een backslash (`\`): `abefnrtv"'?\`. Bovendien escaped hexadecimale getallen zoals bijvoorbeeld `\xff` en escaped octale getallen, zoals bijvoorbeeld `\033` zullen overeenkomen.

HlCChar

- Detecteer een C-teken.

      <HlCChar (gezamenlijke attributen) />

  Deze regel heeft geen specifieke attributen.

  Komt overeen met een C-teken tussen accenten (Bijvoorbeeld: `'c'`). De accenten kunnen een eenvoudig teken zijn of een escaped teken. Zie HlCStringChar voor overeenkomende reeksen van escaped tekens.

RangeDetect

- Detecteert een tekenreeks met gedefinieerde begin- en eindtekens.

      <RangeDetect char="(teken)"  char1="(teken)" (gezamenlijke attributen) />

  `char` defines the character starting the range, `char1` the character ending the range.

  Bruikbaar om bijvoorbeeld kleine tekenreeksen of zoiets te detecteren, maar merk op dat de accentiëringsengine werkt op één regel tegelijk, hierdoor zullen tekenreeksen over meerdere regels niet gevonden worden.

LineContinue

- Komt overeen met een gespecificeerd teken aan het eind van een regel.

      <LineContinue (gezamenlijke attributen) [char="\"] />

  `char` optioneel teken dat moet overeenkomen, standaard is de backslash (`'\'`). Nieuw sinds &kde; 4.13.

  Deze regel is bruikbaar voor het omschakelen van context aan het einde van een regel. Dit is bijvoorbeeld nodig in C/C++ om macro's of tekenreeksen door te laten lopen.

IncludeRules

- Voeg regels in uit een ander context- of taalbestand.

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

  Het attribuut `context` definieert welke context in te voegen.

  Als het een eenvoudige tekenreeks is dan zijn alle gedefinieerde regels in de huidige context ingevoegd, bijvoorbeeld:

      <IncludeRules context="anotherContext" />

  Als de tekenreeks `##` bevat zal het accentueringssysteem zoeken naar een context uit een andere taaldefinitie met de gegeven naam, bijvoorbeeld

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

  zou de context String uit de accentueringsdefinitie van C++ invoegen.

  Als attribuut `includeAttrib` true is, dan wijzigt het doelattribuut naar die van de bron. Dit is vereist om bijvoorbeeld het aanbrengen van commentaar te laten werken als tekst die overeenkomt met de ingevoegde context een verschillende accentuering is van de host-context.

DetectSpaces

- Detecteert witruimte.

      <DetectSpaces (gezamenlijke attributen) />

  Deze regel heeft geen specifieke attributen.

  Gebruik deze regel als u weet dat er verschillende witruimtes aankomen, bijvoorbeeld aan het begin van inspringende regels. Deze regel slaat alle witruimte in een keer over, in plaats van testen met meerdere regels en een voor een overslaan vanwege geen overeenkomst.

DetectIdentifier

- Detecteer tekenreeksen voor een identifier (als een reguliere expressie: [a-zA-Z_][a-zA-Z0-9_]*).

      <DetectIdentifier (gezamenlijke attributen) />

  Deze regel heeft geen specifieke attributen.

  Gebruik deze regel om een reeks woordtekens in een keer over te slaan, in plaats van deze te testen met meerdere regels en ze een voor een over te slaan omdat er geen overeenkomst is.

### Tips & trucs

Als u hebt begrepen hoe het omschakelen van context werkt zal het gemakkelijk zijn om definities voor accentuering te schrijven. Hoewel u zeer zorgvuldig moet controleren welke regel u kiest in welke situatie. Reguliere expressies zijn erg krachtig, maar ze zijn langzaam vergeleken met de andere regels. Dus zou u de volgende tips nog eens moeten bekijken.

- Als u alleen twee tekens wilt laten overeenkomen gebruik dan `Detect2Chars` in plaats van `StringDetect`. Hetzelfde is van toepassing op `DetectChar`.

- Reguliere expressies zijn gemakkelijk te gebruiken maar vaak is er een andere veel snellere manier om hetzelfde resultaat te behalen. U wilt alleen een overeenkomst vinden met het teken `'#'` als het het eerste teken is in de regel. Een oplossing gebaseerd op een reguliere expressie zou er zo uit zien:

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

  . U kunt hetzelfde veel sneller bereiken door te gebruiken:

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

  . Als u de reguliere expressie `'^#'` wilt laten vereen komen dan kunt u nog steeds `DetectChar` gebruiken met het attribuut `column="0"`. Het attribuut `column` telt tekens zodat een tab nog één teken is.

- U kunt van contexts wisselen zonder tekens te bewerken. Neem aan dat u van context wilt wisselen wanneer u de tekenreeks `*/` tegenkomt, maar u moet die tekenreeks in de volgende context bewerken. De onderstaande regel zal overeenkomen en het attribuut `lookAhead` zal de overeenkomende tekenreeks voor accentuering bewaren voor de volgende context.

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

- Gebruik `DetectSpaces` als u weet dat er veel witruimtes zijn.

- Gebruik `DetectIdentifier` in plaats van de reguliere expressie `'[a-zA-Z_]\w*'`.

- Gebruik standaard stijlen wanneer dat kan. Op deze manier vindt de gebruiker een bekende omgeving.

- Kijk in andere XML-bestanden om te zien hoe andere mensen ingewikkelde regels implementeren.

- U kunt elk XML-bestand valideren door het commando `xmllint --dtdvalid language.dtd mySyntax.xml` te gebruiken.

- Als u complexe reguliere expressies erg vaak gebruikt dan kunt u ENTITIES gebruiken. Voorbeeld:

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

  Nu kunt u &myref; gebruiken in plaats van de reguliere expressie.