<?xml version="1.0" encoding='Windows-1251'?>
<!DOCTYPE hrc PUBLIC "-//Cail Lomecb//DTD Colorer HRC take5//EN"
  "http://colorer.sf.net/2003/hrc.dtd">
<hrc version="take5" xmlns="http://colorer.sf.net/2003/hrc"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://colorer.sf.net/2003/hrc http://colorer.sf.net/2003/hrc.xsd">

 <type name="d">
  <annotation><documentation>
    D syntax description
    http://www.digitalmars.com/d/

    The latest version can be found here:
    http://thecybershadow.net/d/colorer/
  </documentation><contributors><![CDATA[
    Vladimir Panteleev <thecybershadow@gmail.com>

    Loosely based on the C/C++ schemes (c.hrc, cpp.hrc)
  ]]></contributors></annotation>

  <import type="def"/>

  <region name="String" parent="def:String"/>
  <region name="EscapeSequence" parent="def:StringContent"/>
  <region name="Character" parent='def:Character'/>
  <region name="CharacterEntity" parent='def:Parameter'/>

  <region name="LineComment" parent="def:LineComment"/>
  <region name="Comment" parent="def:Comment"/>
  <region name="CommentDoc" parent="def:CommentDoc"/>

  <region name="Number" parent="def:Number"/>
  <region name="NumberSuffix" parent="def:NumberSuffix"/>
  <region name="Symbol" parent="def:Symbol"/>
  <region name="StructureSymbol" parent="def:SymbolStrong"/>

  <region name="SpecialToken" parent="def:Directive"/>
  <region name="SpecialTokenWord" parent="def:DirectiveContent"/>
  <region name="AsmCode" parent="def:Directive"/>

  <region name="Keyword" parent="def:Keyword"/>
  <region name="KeywordType" parent="Keyword"/>   <!-- a standard (not base) type, like "string" in D 2.0 (which is just an alias) -->

  <region name="KeywordLibFunctions" parent="def:FunctionKeyword"/>

  <region name="Label" parent="def:Label"/>

  <region name="StructOutline" parent="def:Outlined"/>
  <region name="UnionOutline" parent="StructOutline"/>
  <region name="EnumOutline" parent="StructOutline"/>
  <region name="FuncOutline" parent="def:Outlined"/>
  <region name="DefineOutline" parent="def:Outlined"/>
  <region name="IncludeOutline" parent="def:Outlined"/>
  <region name="ClassOutline" parent="StructOutline"/>
  <region name="InterfaceOutline" parent="ClassOutline"/>
  <region name="VersionOutline" parent="DefineOutline"/>
  <region name="InitializerOutline" parent="FuncOutline"/>
  <region name="VersionOutline" parent="def:Outlined"/>
  
  <scheme name="NestingBlockComment">
   <!-- TODO: Documentation keywords -->
   <block start="/\/\+\+/" end="/\+\//" scheme="NestingBlockComment" region="CommentDoc" region00="def:PairStart" region10="def:PairEnd"/>
   <block start="/\/\+/"   end="/\+\//" scheme="NestingBlockComment" region="Comment"    region00="def:PairStart" region10="def:PairEnd"/>
  </scheme>

  <scheme name="Comments">
   <!-- documentation comments -->
   <regexp match="/\/\*\*\//" region="CommentDoc"/>
   <block start="/\/\/\//" end="/$/"    scheme="def:Comment"   region="CommentDoc"/>
   <block start="/\/\*\*/" end="/\*\//" scheme="def:Comment"   region="CommentDoc" region00="def:PairStart" region10="def:PairEnd"/>

   <block start="/\/\//"   end="/$/"    scheme="def:Comment"   region="LineComment"/>
   <block start="/\/\*/"   end="/\*\//" scheme="def:Comment"   region="Comment"    region00="def:PairStart" region10="def:PairEnd"/>

   <inherit scheme="NestingBlockComment"/>
  </scheme>

  <scheme name="AsmCode">
   <inherit scheme="Comments"/>
   <regexp match="/&#34;(\\.|[^\\&#34;])*?&#34;/" region0="String"/>
   <inherit scheme="def:CHexNumber"/>
   <inherit scheme="asm:baseasm"/>
  </scheme>

  <scheme name="Character">
   <regexp match="/'(\\)(&amp;([a-zA-Z])+;)'/x" region="Character" region1="EscapeSequence" region2="CharacterEntity"/>
   <regexp match="/'(\\['&#34;?\\abfnrtv\x1A] | \\[0-7]{1,3} | \\x[\da-fA-F]{2} | \\u[\da-fA-F]{4} | \\U[\da-fA-F]{8} | \\&amp;[a-zA-Z]+;)'/x" region="Character" region1="EscapeSequence" />
   <regexp match="/'[^\\']'/x" region="Character"/>
   <regexp match="/'.*?'/" region="def:Error"/>
  </scheme>

  <scheme name="String">
   <block start="/(?{def:StringEdge}r&#34;)/" end="/(?{def:StringEdge}&#34;[cwd]?)/" scheme="def:empty"        region="String" inner-region="yes" region00="PairStart" region10="PairEnd"/>
   <block start="/(?{def:StringEdge}x&#34;)/" end="/(?{def:StringEdge}&#34;[cwd]?)/" scheme="HexStringContent" region="String" inner-region="yes" region00="PairStart" region10="PairEnd"/>
   <block start="/(?{def:StringEdge}`)/"      end="/(?{def:StringEdge}`[cwd]?)/"     scheme="def:empty"        region="String" inner-region="yes" region00="PairStart" region10="PairEnd"/>
   <block start="/(?{def:StringEdge}&#34;)/"  end="/(?{def:StringEdge}&#34;[cwd]?)/" scheme="StringContent"    region="String" inner-region="yes" region00="PairStart" region10="PairEnd"/>

   <!-- escape sequences are allowed outside "..." -->
   <regexp match="/\\$/" region="def:Error"/>
   <inherit scheme="EscapeSequences"/>
  </scheme>

  <scheme name="EscapeSequences">
   <regexp match="/\\$/" region="EscapeSequence"/>
   <regexp match="/\\['&#34;?\\abfnrtv\x1A]/" region="EscapeSequence"/>
   <regexp match="/\\[0-7]{1,3}/" region="EscapeSequence"/>
   <regexp match="/\\x[\da-fA-F]{2}/" region="EscapeSequence"/>
   <regexp match="/\\u[\da-fA-F]{4}/" region="EscapeSequence"/>
   <regexp match="/\\U[\da-fA-F]{8}/" region="EscapeSequence"/>
   <regexp match="/\\(&amp;[a-zA-Z]+;)/" region="EscapeSequence" region1="CharacterEntity"/>
   <regexp match="/\\./" region="def:Error"/>
  </scheme>

  <scheme name="StringFormatting">
   <regexp match="/\%[\-\+\#0]*?[\d\*]*(\.[\d\*]+)?[Ll]?[SsCcsuidopxXnEefgG]/" region="EscapeSequence"/>
  </scheme>

  <scheme name="StringContent">
   <inherit scheme="EscapeSequences"/>
   <inherit scheme="StringFormatting"/>
  </scheme>

  <scheme name="HexStringContent">
   <regexp match="/[^&#34;\s\da-fA-F]/" region="def:Error"/>
  </scheme>

  <scheme name="SpecialToken">
   <keywords region="SpecialTokenWord">
     <word name="line"/>
   </keywords>
  </scheme>

  <scheme name="d">
   <!-- special tokens -->
   <block start="/^#!/" end="/$/" scheme="Comments" region="Comment"/>
   <block start="/#/" end="/$/" scheme="SpecialToken" region="SpecialToken"/>

   <block start="/(\{)/" end="/(\})/" scheme="d"
          region00="SymbolStrong" region01="PairStart" region10="SymbolStrong" region11="PairEnd"/>

   <!-- thanx to andrei somsikov for bug -->
   <block start="/(\basm)\s*?(\{|$)/" end="/(\})/" scheme="AsmCode"
          region01="AsmCode" region02="StructureSymbol" region10="StructureSymbol" region00="def:PairStart" region11="def:PairEnd"/>

   <inherit scheme="Outlines"/>
   <inherit scheme="Expression"/>
  </scheme>

  <scheme name="Outlines">
   <!-- Note: there seems to be a bug in colorer's outliner... static constructors have "this" written twice (or I'm failing to understand something here) -->
   <!--regexp><![CDATA[
     /^ \M \s* 
     (?{d:InitializerOutline}
      (static \s+ \~? this)
     )

     \s* (\([^\)]*?\)  |  \([^\);]*?)
     \s* ($|\{|\/) /x
   ]]></regexp-->

   <regexp><![CDATA[
     /^ \M \s* 
     (?{d:InitializerOutline}
      ((static \s+)? \~? this)
     )

     \s* (\([^\)]*?\)  |  \([^\);]*?)
     \s* ($|\{|\/) /x
   ]]></regexp>

   <regexp><![CDATA[
     /^ \M \s* 
     (extern\s*\(\s*\w+\s*\)\s*)? 
     (\w [\w*\[\]\s]+? [*\[\]\s]) (delegate \s* \([\w_*~,\[\]\s]*\)\s*)? 

     (?{d:FuncOutline}
      ([\w]+?)
     )

     (\sfor)?~4 (\sif)?~3 (\swhile)?~6 (\sdo)?~3 (\sswitch)?~7 (\scatch)?~6 (\sforeach)?~8
     
     \s* \( (.* \( [^\(\)]* \))* ( [^\)]*?\) | [^\);]*? )
     \s* ($|\{|\/) /x
   ]]></regexp>

   <regexp><![CDATA[
     /\M
     version \s* \( 
     (?{VersionOutline}
       \s* \w+ \s* 
     )
     \)
     /x
   ]]></regexp>

   <regexp><![CDATA[
     /\M
     class \s+
     (?{ClassOutline}
      [\:\w]+ [\:\w\s]*? ([^;]|$)
     )/x
   ]]></regexp>

   <regexp><![CDATA[
     /\M
     interface \s+
     (?{InterfaceOutline}
      [\:\w]+ [\:\w\s]*? ([^;]|$)
     )/x
   ]]></regexp>

   <regexp><![CDATA[
     /^ \M \s*
     (align \([0-9]+\) \s*)?
     struct \s+
     (?{d:StructOutline}
      [\:\w]+ [\:\w\s]*? ([^;]|$)
     )/x
   ]]></regexp>

   <regexp><![CDATA[
     /^ \M \s* union \s+
     (?{UnionOutline}
      [\:\w]+ [\:\w\s]*? ([^;]|$)
     )/x
   ]]></regexp>
   <regexp><![CDATA[
     /^ \M \s* enum \s+
     (?{EnumOutline}
      [\:\w]+ [\:\w\s]*? ([^;]|$)
     )/x
   ]]></regexp>
  </scheme>

  <!-- !!EE: new scheme - Operators -->
  <scheme name="Operators">
   <keywords region="Symbol">
      <symb name="="/>
      <symb name="+"/><symb name="-"/>
      <symb name="/"/><symb name="*"/>
      <symb name="&amp;"/><symb name="^"/>
      <symb name="|"/>
      <symb name=","/><symb name="."/>
      <symb name="!"/><symb name="~"/>
      <symb name="&lt;"/><symb name="&gt;"/>
      <symb name="%"/>
      <symb name="?" region="StructureSymbol"/>
      <symb name=":" region="StructureSymbol"/>
      <symb name="$" region="StructureSymbol"/>
   </keywords>
  </scheme>

  <scheme name="DecNumber">
    <regexp match="/\b[1-9][0-9_]* (?{NumberSuffix}L|u|U|(Lu)|(LU)|(uL)|(UL))?\b/x" region0="def:NumberDec"/>
    <regexp match="/\b0+           (?{NumberSuffix}L|u|U|(Lu)|(LU)|(uL)|(UL))?\b/x" region0="def:NumberDec"/>
  </scheme>

  <scheme name="OctNumber">
    <regexp match="/\b0+   [0-7_]+ (?{NumberSuffix}L|u|U|(Lu)|(LU)|(uL)|(UL))?\b/x" region0="def:NumberOct"/>
  </scheme>

  <scheme name="HexNumber">
    <regexp match="/\b 0[xX][\da-fA-F_]+ (?{NumberSuffix}L|u|U|(Lu)|(LU)|(uL)|(UL))? \b/x" region="def:NumberHex"/>
  </scheme>

  <scheme name="BinNumber">
    <regexp match="/\b 0[bB][01_]+       (?{NumberSuffix}L|u|U|(Lu)|(LU)|(uL)|(UL))? \b/x" region="def:NumberBin"/>
  </scheme>

  <scheme name="FloatNumber">
    <regexp match="/\B          \. \d[\d_]* ([eE][\-+]? \d[\d_]*)? ([LfF]?i?)\b/x" region0="NumberFloat" region2="NumberSuffix"/>
    <regexp match="/\b \d[\d_]* \. \d[\d_]* ([eE][\-+]? \d[\d_]*)? ([LfF]?i?)\b/x" region0="NumberFloat" region2="NumberSuffix"/>
    <regexp match="/\b \d[\d_]*             ([eE][\-+]? \d[\d_]*)  ([LfF]?i?)\b/x" region0="NumberFloat" region2="NumberSuffix"/>
    <regexp match="/\b \d[\d_]*                                    ([LfF]?i )\b/x" region0="NumberFloat" region1="NumberSuffix"/>
    <regexp match="/\b \d[\d_]*                                    ([LfF] i?)\b/x" region0="NumberFloat" region1="NumberSuffix"/>

    <!-- hex floats -->
    <regexp match="/\b 0[xX] ([\da-fA-F][\da-fA-F_]*)? \. [\da-fA-F][\da-fA-F_]* ([pP][\-+]? \d[\d_]*)? ([LfF]?i?)\b/x" region0="NumberFloat" region3="NumberSuffix"/>
    <regexp match="/\b 0[xX]  [\da-fA-F][\da-fA-F_]*                             ([pP][\-+]? \d[\d_]*)  ([LfF]?i?)\b/x" region0="NumberFloat" region2="NumberSuffix"/>
    <regexp match="/\b 0[xX]  [\da-fA-F][\da-fA-F_]*                                                    ( L   ?i )\b/x" region0="NumberFloat" region1="NumberSuffix"/>
  </scheme>

  <scheme name="Number">
    <inherit scheme="FloatNumber"/>
    <inherit scheme="HexNumber"/>
    <inherit scheme="BinNumber"/>
    <inherit scheme="DecNumber"/>
    <inherit scheme="OctNumber"/>
  </scheme>

  <scheme name="BadHex">
    <regexp match="/\b(0x[\da-fA-F_]*?([^\s\W\da-fA-F_]).*?)\b/i" region0="Error"/>
  </scheme>

  <scheme name="Expression">
   <block start="/(\()/" end="/(\))/" scheme="Expression"
          region00="Symbol" region01="PairStart" region10="Symbol" region11="PairEnd"/>
   <block start="/(\[)/" end="/(\])/" scheme="Expression"
          region00="Symbol" region01="PairStart" region10="Symbol" region11="PairEnd"/>
   <block start="/(\{)/" end="/(\})/" scheme="Expression"
          region00="SymbolStrong" region01="PairStart" region10="SymbolStrong" region11="PairEnd"/>

   <!-- Numbers -->
   <inherit scheme="Number"/>
   <inherit scheme="BadHex"/>

   <!-- Comments -->
   <inherit scheme="Comments"/>

   <!-- Bad tokens -->
   <regexp match="/#\w+/" region="def:Error"/>
   <regexp match="/\b[\d\$\`\@]\w+/i" region="def:Error"/>
   <keywords region="def:Error">
      <symb name="["/><symb name="]"/>
      <symb name="{"/><symb name="}"/>
      <symb name="("/><symb name=")"/>
      <symb name="*/"/><symb name="+/"/>
   </keywords>

   <inherit scheme="Character"/>
   <inherit scheme="String"/>

   <regexp match="/^\s*(extern|align|pragma|deprecated|private|package|protected|public|export|static|final|override|abstract|const|auto|scope)(:)/"
    region1="d:Keyword" region2="d:Label"
   />
   <regexp match="/\b(goto|continue|break)\s+(\w+)(;)/"
    region1="d:Keyword" region2="d:Label" region3="d:Character"
   />

   <!-- labels -->
   <regexp match="/^\s*(default)(:)/"
    region1="Keyword" region2="Label"
   />
   <regexp match="/^\s*(\w+\:)\M(\s|$)/" region1="Label"/>

   <!-- Standard D symbols -->
   <keywords region="StructureSymbol">
      <symb name=";"/>
   </keywords>
   <inherit scheme="Operators"/>

   <!-- D Keywords -->
   <keywords region="Keyword">
      <word name="abstract"/>
      <word name="alias"/>
      <word name="align"/>
      <word name="asm"/>
      <word name="assert"/>
      <word name="auto"/>

      <word name="body"/>
      <word name="bool"/>
      <word name="break"/>
      <word name="byte"/>

      <word name="case"/>
      <word name="cast"/>
      <word name="catch"/>
      <word name="cdouble"/>
      <word name="cent"/>
      <word name="cfloat"/>
      <word name="char"/>
      <word name="class"/>
      <word name="const"/>
      <word name="continue"/>
      <word name="creal"/>

      <word name="dchar"/>
      <word name="debug"/>
      <word name="default"/>
      <word name="delegate"/>
      <word name="delete"/>
      <word name="deprecated"/>
      <word name="do"/>
      <word name="double"/>

      <word name="else"/>
      <word name="enum"/>
      <word name="export"/>
      <word name="extern"/>

      <word name="false"/>
      <word name="final"/>
      <word name="finally"/>
      <word name="float"/>
      <word name="for"/>
      <word name="foreach"/>
      <word name="foreach_reverse"/>
      <word name="function"/>

      <word name="goto"/>

      <word name="idouble"/>
      <word name="if"/>
      <word name="ifloat"/>
      <word name="import"/>
      <word name="in"/>
      <word name="inout"/>
      <word name="int"/>
      <word name="interface"/>
      <word name="invariant"/>
      <word name="ireal"/>
      <word name="is"/>

      <word name="lazy"/>
      <word name="long"/>

      <word name="macro"/>
      <word name="mixin"/>
      <word name="module"/>

      <word name="new"/>
      <word name="null"/>

      <word name="out"/>
      <word name="override"/>

      <word name="package"/>
      <word name="pragma"/>
      <word name="private"/>
      <word name="protected"/>
      <word name="public"/>

      <word name="ref"/>
      <word name="real"/>
      <word name="return"/>

      <word name="scope"/>
      <word name="short"/>
      <word name="static"/>
      <word name="struct"/>
      <word name="super"/>
      <word name="switch"/>
      <word name="synchronized"/>

      <word name="template"/>
      <word name="this"/>
      <word name="throw"/>
      <word name="true"/>
      <word name="try"/>
      <word name="typedef"/>
      <word name="typeid"/>
      <word name="typeof"/>

      <word name="ubyte"/>
      <word name="ucent"/>
      <word name="uint"/>
      <word name="ulong"/>
      <word name="union"/>
      <word name="unittest"/>
      <word name="ushort"/>

      <word name="version"/>
      <word name="void"/>
      <word name="volatile"/>

      <word name="wchar"/>
      <word name="while"/>
      <word name="with"/>
   </keywords>

   <keywords region="KeywordType">
      <word name="string"/>
      <word name="wstring"/>
      <word name="dstring"/>

      <word name="buffer"/>
   </keywords>

   <keywords region='KeywordLibFunctions'>
    <word name="main"/>
    <word name="WinMain"/>
    <word name="DllMain"/>
   </keywords>

  </scheme>

 </type>
</hrc>
