Johan
Thelmén

    jth@home.se

Översättare

# Arbeta med syntaxfärgläggning

## Översikt

Syntaxfärgläggning är det som gör att editorn automatiskt visar text med olika stilar/färger, beroende på strängens funktion i relation till filens syfte. Till exempel i programkällkod, så kan kontrollsatser visas i fetstil, medan datatyper och kommentarer får annorlunda färg än resten av texten. Det här ökar textens läsbarhet väsentligt, och hjälper på så sätt författaren att vara effektivare och mer produktiv.

En funktion i Perl, som visas med syntaxfärgläggning.

En funktion i Perl, som visas med syntaxfärgläggning.

Samma kod utan syntaxfärgläggning.

Samma kod utan syntaxfärgläggning.

Av de två exemplen, vilket är lättast att läsa?

&kappname; levereras med ett flexibelt, anpassningsbart och avancerat system för att göra syntaxfärgläggning, och standarddistributionen tillhandahåller definitioner för ett brett område av programspråk, formaterings- och skriptspråk samt andra textfilformat. Dessutom kan du tillhandahålla dina egna definitioner med enkla &XML;-filer.

&kappname; detekterar automatiskt de riktiga syntaxreglerna när du öppnar en fil, baserat på filens &MIME;-typ, som avgörs av dess filändelse, eller om den inte har någon, dess innehåll. Skulle du råka ut för ett dåligt val, kan du ställa in syntaxen som används för hand med menyn Verktyg Färgläggning.

Stilarna och färgerna som används av varje syntaxfärgläggningsläge kan anpassas under fliken Färgläggnińgstextstilar i inställningsdialogrutan, medan &MIME;-typerna och filändelserna det ska användas för hanteras under fliken Lägen och filtyper.

Syntaxfärgläggning finns för att förbättra läsbarheten för riktig text, men du kan inte lita på att den validerar din text. Att markera text för syntax kan vara svårt, beroende på formatet som du använder, och i vissa fall är upphovsmännen till syntaxreglerna stolta om 98 procent av texten visas korrekt, även om du behöver en ovanlig stil för att se de felaktiga 2 procenten.

Du kan ladda ner uppdaterade eller nya definitioner av syntaxfärgläggning från &kappname;s webbplats genom att klicka på knappen Ladda ner färgläggningsfiler... på fliken Lägen och filtyper i inställningsdialogrutan.

## &kappname;s syntaxfärgläggningssystem

Det här avsnittet beskriver &kappname;s syntaxfärgläggningsmekanism i mer detalj. Det är avsett för dig, om du vill veta mer om den, eller om du vill skapa och ändra syntaxdefinitioner.

### Hur det fungerar

Så fort du öppnar en fil, är en av de första sakerna som &kappname;-editorn gör att avgöra vilken syntaxdefinition som ska användas för filen. När filens text läses in, och medan du skriver i den, så analyserar syntaxfärgläggningssystemet texten enligt reglerna som definieras i syntaxdefinitionen och markerar var i den som olika sammanhang och stilar börjar och slutar.

När du skriver in text i dokumentet, så analyseras och markeras den nya texten i farten, så att om du tar bort ett tecken som markeras som början eller slutet på ett sammanhang, så ändras stilen på den omgivande texten i enlighet med detta.

Syntaxdefinitioner som används av &kappname;s syntaxfärgläggningssystem är &XML;-filer, som innehåller

- Regler för att detektera funktionen hos text, organiserade i sammanhangsblock

- Listor med nyckelord

- Definitioner av stilobjekt

När texten analyseras utvärderas detekteringsreglerna i den ordning som de definierades, och om början på den nuvarande strängen matchar en regel, så används motsvarande sammanhang. Startpunkten i texten flyttas till den sista punkten där regeln matchade, och en ny genomgång av reglerna sker, med början i sammanhanget som anges av den matchande regeln.

### Regler

Detekteringsreglerna är centrala för färgläggningsdetekteringssystemet. En regel är en sträng, ett tecken eller ett reguljärt uttryck som texten som ska analyseras matchas mot. Den innehåller information om vilken stil som ska användas för den delen av texten som matchar. Den kan byta arbetssammanhanget för systemet, antingen till ett sammanhang som anges explicit, eller till det föregående sammanhanget som användes av texten.

Reglerna organiseras i sammanhangsgrupper. En sammanhangsgrupp används för de huvudsakliga koncepten i formatets text, till exempel textsträngar inom citationstecken eller kommentarblock i programkällkod. Det här försäkrar att färgläggningssystemet inte behöver gå igenom alla regler när det inte är nödvändigt, och att vissa teckensekvenser i texten kan hanteras annorlunda beroende på det nuvarande sammanhanget.

Sammanhang kan skapas dynamiskt för att till exempel tillåta användning av instansspecifik data i regler.

### Sammanhangsstilar och nyckelord

I vissa programspråk, hanteras heltal annorlunda än flyttal av kompilatorn (programmet som översätter källkoden till körbart binärformat), och det kan finnas tecken som har en särskild mening i en sträng med citationstecken. I sådana fall är det vettigt att visa dem på ett annat sätt än omgivningen så att de är lätta att identifiera när texten läses. Så även om de inte representerar speciella sammanhang, så kan de betraktas som sådana av syntaxfärgläggningssystemet, så att de kan markeras för att visas på ett annorlunda sätt.

En syntaxdefinition kan innehålla så många stilar som krävs för att täcka koncepten i det format den används för.

I många format finns det en lista på ord som representerar ett speciellt koncept. Till exempel i programspråk, så är kontrollsatserna ett koncept, namn på datatyper ett annat, och inbyggda funktioner i språket ett tredje. &kappname;s syntaxfärgläggningssystem kan använda sådana listor för att detektera och markera ord i texten för att visa koncepten för textformaten.

### Standardstilar

Om du öppnar en C++ källkodsfil, en &Java; källkodsfil och ett HTML-dokument i &kappname;, så ser du att även om formaten är olika, och olika ord därför väljes för särskild behandling, så är färgerna som används samma. Det här beror på att &kappname; har en fördefinierad lista med standardstilar, som används av varje individuell syntaxdefinition.

Det här gör det lätt att känna igen liknande koncept i olika textformat. Kommentarer finns till exempel i nästa alla program-, skript- eller formateringsspråk, och när de visas med samma stil i alla språk, behöver du inte stanna och tänka efter för att identifiera dem i texten.

Alla stilar i en syntaxdefinition använder en av standardstilarna. Några få syntaxdefinitioner använder fler stilar än det finns som standard, så om du ofta använder ett format, kan det vara värt att titta i inställningsdialogrutan för att se om några koncept använder samma stil. Det finns till exempel bara en standardstil för strängar, men eftersom programspråket Perl hanterar två sorters strängar, kan du utöka färgläggningen genom att ställa in dessa så att de skiljer sig något. Alla tillgängliga standardstilar förklaras senare.

## &XML; formatet för syntaxfärgläggningsdefinitioner

### Översikt

Det här avsnittet är en översikt av färgläggningsdefinitionernas &XML;-format. Det beskriver huvudkomponenterna och deras betydelse och användning, och går djupare in i detaljerna för detekteringsreglerna.

Den formella definitionen, också kallad en DTD, lagras i filen `language.dtd` som ska finnas installerad på ditt system i katalogen `$`KDEDIR`/share/apps/kate/syntax`.

#### Huvudkomponenter i &kappname;s färgläggningsdefinitioner

En syntaxfärgläggningsfil innehåller ett huvud som anger XML-versionen och dokumenttypen:

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

Definitionsfilens rot är elementet `language`. Följande egenskaper är tillgängliga:

  Egenskaper som krävs:

  `name` anger språkets namn. Det visas senare i menyer och dialogrutor.

  `section` anger kategorin.

  `extensions` definierar filändelser, som "*.cpp;*.h".

  Valfria egenskaper:

  `mimetype` kopplar filer baserat på &MIME;-typ.

  `version` anger definitionsfilens aktuella version.

  `kateversion` anger senaste version av &kappname; som stöds.

  `casesensitive` definierar om nyckelord är skiftlägeskänsliga eller inte.

  `priority` krävs om en annan syntaxfärgläggningsfil använder samma filändelse. Den högsta prioriteten vinner.

  `author` innehåller författarens namn och e-postadress.

  `license` innehåller licensen, oftast LGPL, Artistic, GPL och andra.

  `hidden` definierar om namnet ska visas i &kappname;s menyer.

  Nästa rad kan alltså se ut så här:

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

Därefter kommer elementet `highlighting` som innehåller det valfria elementet `list` och det nödvändiga elementen `contexts` och `itemDatas`.

  `list` element innehåller en lista med nyckelord. I det här fallet är nyckelorden class och const. Du kan lägga till så många listor som du behöver.

  Elementet `contexts` innehåller alla sammanhang. Det första sammanhanget är förvalt som start för färgläggningen. Det finns två regler i sammanhanget Normal Text som matchar listan av nyckelord med namnet något-namn och en regel som detekterar ett citationstecken och byter sammanhang till string. För att lära dig mer om regler, läs nästa kapitel.

  Den tredje delen är elementet `itemDatas`. Det innehåller alla färger och teckenstilar som behövs av sammanhangen och reglerna. I det här exemplet används `itemData` Normal Text, String och Keyword.

      <highlighting>
          <list name="något-namn">
            <item> class </item>
            <item> const </item>
          </list>
          <contexts>
            <context attribute="Normal Text" lineEndContext="#pop" name="Normal Text" >
              <keyword attribute="Keyword" context="#stay" String="något-namn" />
              <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>

Den sista delen av färgläggningsdefinitionen är den valfria sektionen `general`. Den kan innehålla information om nyckelord, kodvikning, kommentarer och indentering.

  Sektionen `comment` definierar den sträng som enradskommentarer inleds med. Du kan också definiera flerradskommentarer med multiLine och den ytterligare egenskapen end. Det är användbart när användaren trycker på snabbtangenten som motsvarar kommentera/avkommentera.

  Sektionen `keywords` definierar om listor med nyckelord är skiftlägeskänsliga eller inte. Andra egenskaper förklaras senare.

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

### Sektionerna i detalj

Den här delen beskriver alla tillgängliga egenskaper för sammanhang, itemData, nyckelord, kommentarer, kodvikning och indentering.

Elementet `context` hör till gruppen `contexts`. Själva sammanhanget definierar sammanhangsspecifika regler, som vad som ska ske om färgläggningssystemet når slutet på en rad. Tillgängliga egenskaper är:

  `name` är sammanhangets namn. Regler använder namnet för att ange sammanhanget att byta till om regeln matchar.

  `lineEndContext` definierar sammanhanget som färgläggningssystemet byter till om det når ett radslut. Det kan antingen vara namnet på ett annat sammanhang, `#stay` för att inte byta sammanhang (dvs. göra ingenting) eller `#pop` som gör att sammanhanget lämnas. Det är till exempel möjligt att använda `#pop#pop#pop` för att återgå tre steg.

  `lineEmptyContex` definierar sammanhanget om en tom rad påträffas. Förval: #stay.

  `fallthrough`definierar om färgläggningssystemet byter till sammanhanget som anges i fallthroughContext om ingen regel matchar. Förval: false.

  `fallthroughContext` anger nästa sammanhang om ingen regel matchar.

  `dynamic` om true kommer sammanhanget ihåg strängar/platsmarkörer som sparats av dynamiska regler. Det behövs till exempel för HERE-dokument. Förval: false.

Elementet `itemData` är i gruppen `itemDatas`. Det definierar teckenstilen och färgerna. Det är alltså möjligt att definiera egna stilar och färger, men vi rekommenderar dock att du håller dig till standardstilarna om möjligt, så att användaren alltid ser samma färger använda i olika språk. Ibland finns det dock inget annat sätt, och det är nödvändigt att ändra färg- och teckenegenskaper. Egenskapens namn och defStyleNum krävs, övriga är valfria. Tillgängliga egenskaper är:

  `name` anger namnet på itemData. Sammanhang och regler använder namnet i egenskapen attribute för att referera till itemData.

  `defStyleNum` definierar vilken standardstil som ska användas. Tillgängliga standardstilar förklaras i detalj senare.

  `color` definierar en färg. Giltiga format är '#rrggbb' eller '#rgb'.

  `selColor` definierar markeringens färg.

  `italic` om true, är texten kursiv.

  `bold` om true, är texten i fetstil.

  `underline` om true, är texten understruken.

  `strikeout` om true, är texten överstruken.

  `spellChecking` om true, kontrolleras textens stavning, annars ignoreras den under stavningskontroll.

Elementet `keywords` i gruppen `general` definierar nyckelordens egenskaper. Tillgängliga egenskaper är:

  `casesensitive` kan vara true eller false. Om det är true, matchas alla nyckelord skiftlägeskänsligt.

  `weakDeliminator` är en lista med tecken som inte fungerar som ordavgränsare. Punkt `'.'` är till exempel en ordavgränsare. Med antagandet att ett nyckelord i en `list` innehåller en punkt, matchar det bara om du anger att punkten är en svag avgränsare.

  `additionalDeliminator` definierar ytterligare avgränsare.

  `wordWrapDeliminator` definierar tecken som en radbrytning kan ske efter.

  Standardavgränsare och radbrytningsavgränsare är tecknen `.():!+,-<=>%&*/;?[]^{|}~\`, mellanslag (`' '`) och tabulator (`'\t'`).

Elementet `comment` i gruppen `comments` definierar kommentaregenskaper som används för Verktyg Kommentera och Verktyg Avkommentera. Tillgängliga egenskaper är:

  `name` är antingen singleLine eller multiLine. Om du väljer multiLine krävs egenskaperna end och region.

  `start` definierar strängen som används för att inleda en kommentar. I C++ skulle det vara "/*".

  `end` definierar strängen som används för att avslutar en kommentar. I C++ skulle det vara "*/".

  `region` ska vara namnet på den vikbara flerraderskommentaren. Med antagandet att du har beginRegion="Comment" ... endRegion="Comment" i dina regler, ska du använda region="Comment". På så sätt fungerar avkommentering även om du inte markerar all text i en flerraderskommentar. Markören måste bara vara inne i flerraderskommentaren.

Elementet `folding` i gruppen `general` definierar kodvikningsegenskaper. Tillgängliga egenskaper är:

  `indentationsensitive` om true läggs kodvikningsmarkörerna till baserat på indentering, som i skriptspråket Python. Oftast behöver du inte ange det, eftersom det har det förvalda värdet false.

Elementet `indentation` i gruppen `general` definierar vilken identerare som ska användas, även om vi starkt rekommenderar att utelämna elementet, eftersom intenteraren oftast anges genom att definiera en filtyp eller genom att lägga till lägesrader i textfilen. Om du dock anger en indenterare, tvingar du användaren att använda en viss indentering, vilket kanske inte alls uppskattas. Tillgängliga egenskaper är:

  `mode` är namnet på indenteraren. Indenterare som för närvarande är tillgängliga är:normal, cstyle, haskell, lilypond, lisp, python, ruby och xml.

### Tillgängliga standardstilar

Standardstilar har redan förklarats. En kort sammanfattning: Standardstilar är fördefinierade stilar för teckensnitt och färger.

Här är alltså bara listan med tillgängliga standardstilar:

  `dsNormal`, används för normal text.

  `dsKeyword`, används för nyckelord.

  `dsDataType`, används för datatyper.

  `dsDecVal`, används för decimala värden.

  `dsBaseN`, används för värden med en bas skild från 10.

  `dsFloat`, används för flyttal.

  `dsChar`, används för ett tecken.

  `dsString`, används för strängar.

  `dsComment`, används för kommentarer.

  `dsOthers`, används för 'andra' saker.

  `dsAlert`, används för varningsmeddelanden.

  `dsFunction`, används för funktionsanrop.

  `dsRegionMarker`, används för områdesmarkeringar.

  `dsError`, används för färgläggning av fel och felaktig syntax.

## Regler för syntaxdetektering

Den här sektionen beskriver reglerna för syntaxdetektering.

Varje regel kan matcha noll eller flera tecken i början av strängen som de ska testa. Om regeln matchar, så tilldelas de matchande tecknen stilen eller egenskapen som definieras av regeln. En regel kan också begära att det nuvarande sammanhanget byts.

En regel ser ut så här:

    <Regelnamn attribute="(identifierare)" context="(identifierare)" [regelspecifika egenskaper] />

Ordet attribute identifierar stilen som ska användas för tecken som matchar med namn eller index, och context identifierar sammanhanget som ska användas i fortsättningen.

Sammanhanget kan identifieras av:

- En identifierare, som är namnet på det andra sammanhanget.

- En ordning som talar om att färgläggningen ska stanna kvar i det nuvarande sammanhanget (`#stay`), eller gå tillbaka till det föregående sammanhanget som använts i strängen (`#pop`).

  För att gå tillbaka flera steg, kan nyckelordet #pop upprepas: `#pop#pop#pop`

Vissa regler kan ha delregler, bara utvärderas om huvudregeln matchar. Hela den matchande strängen kommer att få egenskapen som definieras av huvudregeln. En regel med en delregel ser ut så här:

    <Regelnamn (egenskaper)>
      <Delregelnamn (egenskaper) />
      ...
    </Regelnamn>

Regelspecifika egenskaper varierar och beskrivs i följande avsnitt.

### Gemensamma egenskaper

Alla regler har följande egenskaper gemensamma och är tillgängliga på alla ställen `(gemensamma egenskaper)` visas. Egenskaperna attribute och context är nödvändiga, alla övriga är valfria.

- attribute: En egenskap avbildas på en definierad itemData.

- context: Anger sammanhanget som färgläggningssystemet byter till om regeln matchar.

- beginRegion: Inled ett kodvikningsblock. Förval: unset.

- endRegion: Avsluta ett kodvikningsblock. Förval: unset.

- lookAhead: Om true behandlar inte färgläggningssystemet matchningens längd. Förval: false.

- firstNonSpace: Matcha bara om strängen är den första förutom blanktecken på raden. Förval: false.

- column: Matcha bara om kolumnen matchar. Förval: unset.

### Dynamiska regler

Vissa regler tillåter den valfria egenskapen `dynamic` med Boolesk typ, som har förvalt värde false. Om dynamic är true, kan en regel använda platsmarkörer som representerar texten som matchas av en regel med ett reguljärt uttryck som byter till nuvarande sammanhang med sin egenskap `string` eller `char`. I en `string` ersätts platsmarkören %N (där N är ett tal) med motsvarande N i det anropande reguljära uttrycket. I en `char` måste platsmarkören vara ett tal N och det ersätts med första tecknet i motsvarande N i det anropande reguljära uttrycket. Närhelst en regel tillåter den här egenskapen, innehåller den (dynamic).

- dynamic: kan vara (true | false).

### Reglerna i detalj

DetectChar

  Detektera ett enda specifikt tecken. Används ofta för att till exempel hitta slutet på strängar inom citationstecken.

      <DetectChar char="(tecken)" (gemensamma egenskaper) (dynamisk) />

  Egenskapen `char` definierar tecknet som ska matchas.

Detect2Chars

  Detektera två angivna tecken i en definierad ordning.

      <Detect2Chars char="(tecken)" char1="(tecken)" (gemensamma egenskaper) (dynamisk) />

  Egenskapen `char` definierar det första tecknet som ska matcha, `char1` det andra.

AnyChar

  Detektera ett tecken i en angiven teckenmängd.

      <AnyChar String="(sträng)" (gemensamma egenskaper) />

  Egenskapen `String` definierar teckenmängden.

StringDetect

  Detektera en sträng exakt.

      <StringDetect String="(sträng)" [insensitive="TRUE|FALSE;"] (gemensamma egenskaper) (dynamisk) />

  Egenskapen `String` definierar strängen som ska matcha. Egenskapen `insensitive` (okänslig) är normalt `FALSE` (FALSK) och skickas med till strängjämförelsefunktionen. Om värdet är `TRUE` (SANT) så används en jämförelse som inte bryr sig om skiftläge.

WordDetect

  Detektera en exakt sträng, men kräv dessutom ordgränser som en punkt `'.'` eller ett blanktecken i början och slutet av ordet. Betrakta `\b<string>\b` som ett reguljärt uttryck, men snabbare än regeln `RegExpr`.

      <WordDetect String="(sträng)" [insensitive="TRUE|FALSE;"] (gemensamma egenskaper) (dynamisk) />

  Egenskapen `String` definierar strängen som ska matcha. Egenskapen `insensitive` (okänslig) är normalt `FALSE` (FALSK) och skickas med till strängjämförelsefunktionen. Om värdet är `TRUE` (SANT) så används en jämförelse som inte bryr sig om skiftläge.

  Sedan: Kate 3.5 (KDE 4.5)

RegExpr

  Matchar med ett reguljärt uttryck.

      <RegExpr String="(sträng)" [insensitive="TRUE|FALSE;"] [minimal="TRUE| FALSE"] (gemensamma egenskaper) (dynamisk) />

  Egenskapen `String` definierar det reguljära uttrycket.

  Egenskapen `insensitive` (okänslig) är normalt `FALSE` (FALSK) och skickas med det reguljära uttrycket.

  Egenskapen `minimal` är normalt `FALSE` (FALSK) och skickas med det reguljära uttrycket.

  Eftersom reglerna alltid matchas mot början av den nuvarande strängen, så anger ett reguljärt uttryck som börjar med en hatt (`^`) att regeln bara ska matchas mot radens början.

  Se Reguljära uttryck för mer information om dem.

keyword

  Detektera ett nyckelord från en angiven lista.

      <keyword String="(listnamn)" (gemensamma egenskaper) />

  Egenskapen `String` identifierar en lista på nyckelord med namn. En lista med det namnet måste finnas.

Int

  Detektera ett heltal.

      <Int (gemensamma egenskaper) (dynamisk) />

  Den här regeln har inga specifika egenskaper. Delregler används typiskt för att detektera kombinationer av `L` och `U` efter talet, som anger heltalstypen i programkod. I själva verket tillåts alla regler som delregler, även om `DTD`:n bara tillåter delregeln `StringDetect`.

  Följande exempel matchar heltal som följs av tecknet 'L'.

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

Float

  Detektera ett flyttal.

      <Float (gemensamma egenskaper) />

  Den här regeln har inga specifika egenskaper. `AnyChar` tillåts som en delregel, och används typiskt för att detektera kombinationer, se regeln `Int` för en referens.

HlCOct

  Detektera en oktal talrepresentation.

      <HlCOct (gemensamma egenskaper) />

  Den här regeln har inga specifika egenskaper.

HlCHex

  Detektera en hexadecimal talrepresentation.

      <HlCHex (gemensamma egenskaper) />

  Den här regeln har inga specifika egenskaper.

HlCStringChar

  Detektera ett undantaget tecken.

      <HlCStringChar (gemensamma egenskaper) />

  Den här regeln har inga specifika egenskaper.

  Det matchar bokstavsrepresentationer av osynliga tecken som ofta används i programkod, till exempel `\n` (nyrad) eller `\t` (tabulator).

  Följande tecken matchar om de följer ett bakstreck (`\`): `abefnrtv"'?`. Dessutom matchar undantagna hexadecimala tal, som till exempel `\xff` och undantagna oktala tal, till exempel `\033`.

HlCChar

  Detektera ett C-tecken.

      <HlCChar (gemensamma egenskaper) />

  Den här regeln har inga specifika egenskaper.

  Det matchar C-tecken omgivna av apostrofer (till exempel `'c'`). Det kan finnas ett enkelt tecken eller en teckenföljd inom apostroferna. Se HlCStringChar för matchade teckenföljder.

RangeDetect

  Detektera en sträng med definierade start- och sluttecken.

      <RangeDetect char="(tecken)"  char1="(tecken)" (gemensamma egenskaper) />

  `char` definierar tecknet som inleder intervallet, och `char1` tecknet som avslutar intervallet.

  Användbar för att till exempel detektera små strängar inom citationstecken och liknande, men observera att eftersom färgläggningen arbetar med en rad i taget, så hittar det inte strängar som fortsätter på nästa rad.

LineContinue

  Matchar ett bakstreck (`'\'`) i slutet av en rad.

      <LineContinue (gemensamma egenskaper) />

  Den här regeln har inga specifika egenskaper.

  Den här regeln är användbar för att byta sammanhang vid radslut, om det sista tecknet är ett bakstreck (`'\'`). Det behövs till exempel i C/C++ för att fortsätta makron eller strängar.

IncludeRules

  Inkludera regler från ett annat sammanhang eller språk/fil.

      <IncludeRules context="sammanhangslänk" [includeAttrib="true|false"] />

  Egenskapen `context` definierar vilket sammanhang som ska inkluderas.

  Om den är en enkelt sträng innehåller den alla definierade regler i det nuvarande sammanhanget, till exempel:

      <IncludeRules context="annat-sammanhang" />

  Om strängen börjar med `##` letar syntaxfärgläggningssystemet efter en annan språkdefinition med det givna namnet, till exempel:

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

  Om egenskapen `includeAttrib` är true, ändras målegenskapen till källans egenskap. Det krävs till exempel för att kommentarer ska fungera om text som matchas av det inkluderade sammanhanget har en annan färgläggning än värdsammanhanget.

DetectSpaces

  Detektera blanktecken.

      <DetectSpaces (gemensamma egenskaper) />

  Den här regeln har inga specifika egenskaper.

  Använd den här regeln om du vet att det kan finnas flera blanktecken framför, till exempel i början av indenterade rader. Regeln hoppar över alla blanktecken på en gång, istället för att prova flera regler och hoppa över en åt gången eftersom den inte matchar.

DetectIdentifier

  Detektera strängar för identifierare (som ett reguljärt uttryck: [a-zA-Z_][a-zA-Z0-9_]*).

      <DetectIdentifier (gemensamma egenskaper) />

  Den här regeln har inga specifika egenskaper.

  Använd den här regeln för att hoppa över en sträng med ordtecken på en gång, istället för att testa den med flera regler och hoppa ett steg i taget beroende på att ingenting matchar.

### Tips och trick

När du väl har förstått hur sammanhangsbyte fungerar blir det enkelt att skriva färgläggningsdefinitioner. Du bör ändå kontrollera noggrant vilken regel du väljer i vilken situation. Reguljära uttryck är mycket kraftfulla, men de är långsamma jämfört med andra regler. Du bör därför ta hänsyn till följande tips.

- Om du bara matchar två tecken, använd `Detect2Chars` istället för `StringDetect`. Samma sak gäller för `DetectChar`.

- Reguljära uttryck är enkla att använda, men oftast finns det ett annat mycket snabbare sätt att uppnå samma resultat. Antag att du bara vill matcha tecknet `'#'` om det är det första tecknet på en rad. En lösning baserad på reguljära uttryck skulle se ut så här:

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

  Du kan uppnå samma sak mycket snabbare med:

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

  Om du vill matcha det reguljära uttrycket `'^#'` kan du fortfarande använda `DetectChar` med egenskapen `column="0"`. Egenskapen `column` räknar baserat på tecken, så en tabulator är fortfarande bara ett tecken.

- Du kan byta sammanhang utan att behandla tecken. Antag att du vill byta sammanhang när du stöter på strängen `*/`, men måste behandla denna sträng i nästa sammanhang. Regeln nedan matchar, och egenskapen `lookAhead` gör att färgläggningen behåller den matchade strängen för nästa sammanhang.

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

- Använd `DetectSpaces` om du vet att många blanktecken förekommer.

- Använd `DetectIdentifier` instället för ett reguljärt uttryck `'[a-zA-Z_]\w*'`.

- Använd standardstilar överallt du kan. På så sätt finner användaren en bekant miljö.

- Titta i andra XML-filer för att se hur andra implementerade knepiga regler.

- Du kan validera alla XML-filer genom att använda kommandot `xmllint --dtdvalid language.dtd min-syntax.xml`.

- Om du mycket ofta upprepar komplexa reguljära uttryck kan du använda ENTITETER. Till exempel:

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

  Nu kan du använda &myref; istället för det reguljära uttrycket.