MediaWiki:SyntaxHighlightingRegexps

From LiteratePrograms
Jump to: navigation, search

<?xml version="1.0" encoding="utf-8"?> <syntaxhighlightingregexps>

 <language name="plain">
   <rule>
     <regex><![CDATA[@<<]]></regex>
     <style>noweb escaped less thans</style>
   </rule>
   <rule>
     <regex><![CDATA[(?<!@)<<[^>\n]*?>>(=|\+=)]]></regex>
     <style>noweb chunk header</style>
   </rule>
   <rule>
     <regex><![CDATA[(?<!@)<<[^\n]*?>>]]></regex>
     <style>noweb chunk</style>
   </rule>
 </language>
 <language name="ada" inherit="plain">
   <rule>
     <regex><![CDATA[--.*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[".*?("|$)]]></regex>
     <style>string</style>
   </rule>
   <rule>
     <regex><![CDATA['.']]></regex>
     <style>character</style>
   </rule>
   <rule>
     <regex><![CDATA['[a-zA-Z][a-zA-Z_]+\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[(((2|8|10|16)#[_0-9a-fA-F]*#)|[0-9.]+)]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(?i)((with|pragma|use)[ \t\n\f\r]+[a-zA-Z0-9_.]+;)+\b]]></regex>
     <style>include</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(?i)(boolean|character|count|duration|float|integer|long_float|long_integer|priority|short_float|short_integer|string)\b]]></regex>
     <style>predefined type</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(?i)field|natural|number_base|positive|priority\b]]></regex>
     <style>predefined type</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(?i)(abort|abs|accept|access|and|array|at|begin|body|case|constant|declare|delay|delta|digits|do|else|elsif|end|entry|exception|exit|for|function|generic|goto|if|in|is|limited|loop|mod|new|not|null|of|or|others|out|package|pragma|private|procedure|raise|range|record|rem|renames|return|reverse|select|separate|subtype|task|terminate|then|type|use|when|while|with|xor)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(?i)(abstract|tagged|all|protected|aliased|requeue|until)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b[a-zA-Z][a-zA-Z0-9_]*\b]]></regex>
     <style>identifier</style>
   </rule>
   <rule>
     <regex><![CDATA[(?i)\.all\b]]></regex>
     <style>predefined identifier</style>
   </rule>
 </language>
 <language name="ada95" inherit="ada"/>
 <language name="awk" inherit="plain">
   <rule>
     <regex><![CDATA[#.*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[""|".*?([^\\](\\\\)*)"|"\\\\"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[|'.*?([^\\](\\\\)*)'|'\\\\']]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[function[\t ]+([a-zA-Z0-9_]+)[\t \n]*(\{|\n)]]></regex>
     <style>function header</style>
     <rule>
       <regex><![CDATA[[\t ]([a-zA-Z0-9_]+)]]></regex>
       <style>function header name</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[(\b| )?(/)(\\/|[^/\n])*(/[gimesox]*)]]></regex>
     <style>regex</style>
   </rule>
   <rule>
     <regex><![CDATA[(?:\b| )(?:(?:m|q|qq)([!"#$%&'*+-/]))(\\\2|[^\2\n])*(\2[gimesox]*)]]></regex>
     <style>regex</style>
   </rule>
   <rule>
     <regex><![CDATA[(?:\b| )?(?:s([!"#$%&'*+-/]))(?:\\\2|[^\2\n])*?(\2)[^(\2)\n]*?(\2[gimesox]*)]]></regex>
     <style>regex</style>
   </rule>
   <rule>
     <regex><![CDATA[(?:\b| )(?:(?:tr|y)([^\w\s]))(?:\\\2|[^\2\n])*?(\2)[^(\2)\n]*?(\2[gimesox]*)]]></regex>
     <style>regex</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(BEGIN|END|ARGC|ARGIND|ARGV|CONVFMT|ENVIRON|ERRNO|FIELDWIDTHS|FILENAME|FNR|FS|IGNORECASE|NF|NR|OFMT|OFS|ORS|RS|RT|RSTART|RLENGTH|SUBSEP)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(if|while|do|for|in|break|continue|delete|exit|next|nextfile|function)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(close|getline|print|printf|system|fflush|atan2|cos|exp|int|log|rand|sin|sqrt|srand|gensub|gsub|index|length|split|sprintf|sub|substr|tolower|toupper|systime|strftime)\b]]></regex>
     <style>library function</style>
   </rule>
   <rule>
     <regex><![CDATA[[\[\]\{\}\(\)]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[<<'([^\n]*)';.*?^\1$]]></regex>
     <style>text</style>
   </rule>
   <rule>
     <regex><![CDATA[<<([^\n]*).*?^\1$]]></regex>
     <style>text</style>
   </rule>
 </language>
 <language name="c" inherit="plain">
   <rule>
     <regex><![CDATA[/\*\*.*?\*/]]></regex>
     <style>doc comment</style>
   </rule>
   <rule>
     <regex><![CDATA[/\*.*?\*/]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA["([^\\"]|(\\.))*"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[^[ \t]*#.*?$]]></regex>
     <style>preprocessor</style>
     <rule>
       <regex><![CDATA[""|".*?([^\\](\\\\)*)"|"\\\\"]]></regex>
       <style>string</style>
       <rule>
         <regex><![CDATA[\\.]]></regex>
         <style>esc character</style>
       </rule>
     </rule>
     <rule>
       <regex><![CDATA[<.*?>]]></regex>
       <style>string</style>
     </rule>
     <rule>
       <regex><![CDATA[[^/]/\*.*?\*/]]></regex>
       <style>comment</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA['(\\)?.']]></regex>
     <style>character</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character'</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(const|extern|auto|register|static|unsigned|signed|volatile|char|double|float|int|long|short|void|typedef|struct|union|enum)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(return|goto|if|else|case|default|switch|break|continue|while|do|for|sizeof)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[[\{\}]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[([\*\-\+=:;%&\|<>\(\)\[\]!])]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9]*)]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="c++" inherit="plain">
   <rule>
     <regex><![CDATA[/\*\*.*?\*/]]></regex>
     <style>doc comment</style>
   </rule>
   <rule>
     <regex><![CDATA[/\*.*?\*/]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[1]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[""|"\\\\"|".*?([^\\](\\\\)*)"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[^[ \t]*#.*?$]]></regex>
     <style>preprocessor</style>
     <rule>
       <regex><![CDATA[""|".*?([^\\](\\\\)*)"|"\\\\"]]></regex>
       <style>string</style>
       <rule>
         <regex><![CDATA[\\.]]></regex>
         <style>esc character</style>
       </rule>
     </rule>
     <rule>
       <regex><![CDATA[<.*?>]]></regex>
       <style>string</style>
     </rule>
     <rule>
       <regex><![CDATA[[^/]/\*.*?\*/]]></regex>
       <style>comment</style>
     </rule>
     <rule>
       <regex><![CDATA[2]]></regex>
       <style>comment</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA['(\\)?.']]></regex>
     <style>character</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(class|typename|typeid|template|friend|virtual|inline|explicit|operator|overload|public|private|protected|const|extern|auto|register|static|mutable|unsigned|signed|volatile|char|double|float|int|long|short|bool|wchar_t|void|typedef|struct|union|enum)\b]]></regex>
     <style>reserved word</style>
                                               ,
   </rule>
   <rule>
     <regex><![CDATA[\b(new|delete|this|return|goto|if|else|case|default|switch|break|continue|while|do|for|catch|throw|sizeof|true|false|namespace|using|dynamic_cast|static_cast|reinterpret_cast)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[[\{\}]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[([\*\-\+=:;%&\|<>\(\)\[\]!])]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9]*)]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="cc" inherit="c++"/>
 <language name="cpp" inherit="c++"/>
 <language name="cxx" inherit="c++"/>
 <language name="h" inherit="c++"/>
 <language name="hpp" inherit="c++"/>
 <language name="gpasm" inherit="plain">
   <rule>
     <regex><![CDATA[^.*$]]></regex>
     <style>symbol</style>
     <rule>
       <regex><![CDATA[;.*?$]]></regex>
       <style>comment</style>
     </rule>
     <rule>
       <regex><![CDATA[^[A-Za-z_][A-Za-z_0-9]*:?]]></regex>
       <style>identifier</style>
     </rule>
     <rule>
       <regex><![CDATA[^[ \t]+[A-Za-z_][A-Za-z_0-9]*]]></regex>
       <style>reserved word</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[""|".*?([^\\](\\\\)*)"|"\\\\"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
 </language>
 <language name="forth" inherit="plain">
   <rule>
     <regex><![CDATA[\( [^\)]*\)]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[\\ .*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[\.\".*?\"]]></regex>
     <style>string</style>
   </rule>
   <rule>
     <regex><![CDATA[\[char\] .]]></regex>
     <style>character</style>
   </rule>
   <rule>
     <regex><![CDATA[char .]]></regex>
     <style>character</style>
   </rule>
   <rule>
           <regex><![CDATA[\b(2drop|2dup|2nip|2over|2rot|2swap|abort|allot|base|bl|bye|catch|constant|cr|create|decimal|defer|do|else|erase|execute|exit|fill|here|hex|is|i|j|loop|lshift|negate|ip|pad|recurse|rshift|space|throw|to|tuck|type|value|variable|within|abs|again|align|aligned|and|begin|case|cell|cells|char|chars|drop|dup|emit|endif|endof|float|floats|if|invert|mod|of|or|over|pick|repeat|rot|swap|then|until|while|xor)\b]]></regex>
     <style>reserved word</style>
   </rule>
 </language>
 <language name="groff" inherit="plain">
   <rule>
     <regex><![CDATA[\\".*?$]]></regex>
     <style>comment</style>
   </rule>
 </language>
 <language name="html" inherit="plain">
   <rule>
     <regex><![CDATA[]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[\&[-.a-zA-Z0-9#]*;?]]></regex>
     <style>html entity</style>
   </rule>
   <rule>
     <regex><![CDATA[<(/|!)?[-.a-zA-Z0-9]*.*?>]]></regex>
     <style>predefined identifier</style>
     <rule>
       <regex><![CDATA[".*?"]]></regex>
       <style>string</style>
     </rule>
     <rule>
       <regex><![CDATA['.*?']]></regex>
       <style>string</style>
     </rule>
     <rule>
       <regex><![CDATA[[<>]]]></regex>
       <style>braces</style>
     </rule>
     <rule>
       <regex><![CDATA[[^'" ]+(?=.)]]></regex>
       <style>identifier</style>
     </rule>
   </rule>
 </language>
 <language name="icon" inherit="plain">
   <rule>
     <regex><![CDATA[#.*$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[""|"(\\\\)*"|".*?([^\\](\\\\)*)"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(~)?[0-9]+)?)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[(null|integer|real|string|cset|file|co-expression|list|table|set)]]></regex>
     <style>predefined types</style>
   </rule>
   <rule>
     <regex><![CDATA[[\[\]\(\)\{\}]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[break|by|case|create|default|do|else|end|every|fail|global|if|initial|link|local|next|not|of|procedure|record|repeat|return|static|suspend|then|to|until|while]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[(\+\+|\+|--|-|\|\|\||\|\||\?|!|\*\*|\*|/|\\|%|\^|\~===|===|==|=|\~=|\~|<->|<=|>=|<|>|;|:=:|:=|:|,|\.)]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9]*)]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="java" inherit="plain">
   <rule>
     <regex><![CDATA[/\*\*.*?\*/]]></regex>
     <style>doc comment</style>
   </rule>
   <rule>
     <regex><![CDATA[/\*.*?\*/]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[3]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[""|".*?([^\\](\\\\)*)"|"\\\\"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[|'.*?([^\\](\\\\)*)'|'\\\\']]></regex>
     <style>string</style>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(import|package)\b.*?$]]></regex>
     <style>include</style>
     <rule>
       <regex><![CDATA[\\(.|\n)]]></regex>
       <style>esc character</style>
     </rule>
     <rule>
       <regex><![CDATA[[^/]/\*.*?\*/]]></regex>
       <style>comment</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b(abstract|boolean|byte|char|class|double|extends|final|float|int|interface|long|native|private|protected|public|short|static|transient|synchronized|void|volatile|implements)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(break|case|catch|continue|default|do|else|false|finally|for|if|instanceof|new|null|return|super|switch|this|throw|throws|true|try|while)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[[\{\}\(\)\[\]]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[\b[a-zA-Z_][a-zA-Z0-9_]*\b]]></regex>
     <style>identifier</style>
   </rule>
   <rule>
     <regex><![CDATA[([\*\-\+=:;%&\|<>!])]]></regex>
     <style>symbol</style>
   </rule>
 </language>
 <language name="javascript" inherit="plain">
   <rule>
     <regex><![CDATA[/\*.*?\*/]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[4]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(onAbort|onBlur|onClick|onChange|onDblClick|onDragDrop|onError|onFocus|onKeyDown|onKeyPress|onLoad|onMouseDown|onMouseMove|onMouseOut|onMouseOver|onMouseUp|onMove|onResize|onSelect|onSubmit|onUnload)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[[\{\}]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(break|continue|else|for|if|in|new|return|this|typeof|var|while|with)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[function[\t ]+([a-zA-Z0-9_]+)[\t \(]+.*?[\n{]]]></regex>
     <style>function header</style>
     <rule>
       <regex><![CDATA[\(.*?\)]]></regex>
       <style>function header args</style>
     </rule>
     <rule>
       <regex><![CDATA[[\t ][a-zA-Z0-9_]+]]></regex>
       <style>function header name</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b(anchor|Applet|Area|Array|button|checkbox|Date|document|elements|FileUpload|form|frame|Function|hidden|history|Image|link|location|Math|navigator|Option|password|Plugin|radio|reset|select|string|submit|text|textarea|window)\b]]></regex>
     <style>predefined type</style>
   </rule>
   <rule>
     <regex><![CDATA[".*?("|$)]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[(aliceblue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|blanchedalmond|blue|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dodgerblue|firebrick|floralwhite|forestgreen|fuchsia|gainsboro|ghostwhite|gold|goldenrod|gray|green|greenyellow|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightsteelblue|lightyellow|lime|limegreen|linen|magenta|#008000|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|navy|oldlace|olive|olivedrab|orange|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|purple|red|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|silver|skyblue|slateblue|slategray|snow|springgreen|steelblue|tan|teal|thistle|tomato|turquoise|violet|wheat|white|whitesmoke|yellow|yellowgreen|#[A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9])]]></regex>
       <style>identifier</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA['.*?('|$)]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[(aliceblue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|blanchedalmond|blue|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dodgerblue|firebrick|floralwhite|forestgreen|fuchsia|gainsboro|ghostwhite|gold|goldenrod|gray|green|greenyellow|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightsteelblue|lightyellow|lime|limegreen|linen|magenta|#008000|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|navy|oldlace|olive|olivedrab|orange|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|purple|red|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|silver|skyblue|slateblue|slategray|snow|springgreen|steelblue|tan|teal|thistle|tomato|turquoise|violet|wheat|white|whitesmoke|yellow|yellowgreen|#[A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9][A-Fa-f0-9])]]></regex>
       <style>identifier</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b(captureEvents|releaseEvents|routeEvent|handleEvent)\b.*?(\)|$)]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(abs|acos|alert|anchor|asin|atan|atan2|back|big|blink|blur|bold|ceil|charAt|clear|clearTimeout|click|close|confirm|cos|escape|eval|exp|fixed|floor|focus|fontcolor|fontsize|forward|getDate|getDay|getHours|getMinutes|getMonth|getSeconds|getTime|getTimezoneOffset|getYear|go|indexOf|isNaN|italics|javaEnabled|join|lastIndexOf|link|log|max|min|open|parse|parseFloat|parseInt|pow|prompt|random|reload|replace|reset|reverse|round|scroll|select|setDate|setHours|setMinutes|setMonth|setSeconds|setTimeout|setTime|setYear|sin|small|sort|split|sqrt|strike|sub|submit|substring|sup|taint|tan|toGMTString|toLocaleString|toLowerCase|toString|toUpperCase|unescape|untaint|UTC|write|writeln)\b]]></regex>
     <style>library function</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(action|alinkColor|anchors|appCodeName|appName|appVersion|bgColor|border|checked|complete|cookie|defaultChecked|defaultSelected|defaultStatus|defaultValue|description|E|elements|enabledPlugin|encoding|fgColor|filename|forms|frames|hash|height|host|hostname|href|hspace|index|lastModified|length|linkColor|links|LN2|LN10|LOG2E|LOG10E|lowsrc|method|name|opener|options|parent|pathname|PI|port|protocol|prototype|referrer|search|selected|selectedIndex|self|SQRT1_2|SQRT2|src|status|target|text|title|top|type|URL|userAgent|value|vlinkColor|vspace|width|window)\b]]></regex>
     <style>predefined identifier</style>
   </rule>
   <rule>
     <regex><![CDATA[([=;->/&|])]]></regex>
     <style>symbol</style>
   </rule>
 </language>
 <language name="js" inherit="javascript"/>
 <language name="lisp" inherit="plain">
   <rule>
     <regex><![CDATA()]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[;.*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[".*?("|$)]]></regex>
     <style>string</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(defun |xyz)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[(#\([0-9]+ [0-9]+\)|[0-9]+)]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[([-a-zA-Z]+)]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="lua" inherit="plain">
   <rule>
     <regex><![CDATA[--\[\[.*?\]\]]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[--.*$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[""|"(\\\\)*"|".*?([^\\](\\\\)*)"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(~)?[0-9]+)?)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[[\[\]\(\)\{\}]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[and|break|do|else|elseif|end|false|for|function|if|in|local|nil|not|or|repeat|return|then|true|until|while]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[(\+|-|\*|/|\^|==|=|\~=|<=|>=|<|>|;|:|,|\.\.\.|\.\.|\.)]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9]*)]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="acl2" inherit="lisp" />
 <language name="m4" inherit="plain">
   <rule>
     <regex><![CDATA[dnl.*?$]]></regex>
     <style>doc comment</style>
   </rule>
   <rule>
     <regex><![CDATA[#.*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(define|undefine|defn|pushdef|popdef|indir|builtin|changequote|changecom|changeword|m4wrap|m4exit|include|sinclude|divert|undivert|divnum|cleardiv|shift|dumpdef|traceon|traceoff|debugfile|debugmode|len|index|regexp|substr|translit|patsubst|format|incr|decr|syscmd|esyscmd|sysval|maketemp|errprint)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(ifdef|ifelse|loops)\b]]></regex>
     <style>reserved word</style>
     <rule>
       <regex><![CDATA[[$]\$?({[^}]*}|[^a-zA-Z0-9_/\t\n\.,\\[\\{\\(]|[0-9]+|[a-zA-Z_][a-zA-Z0-9_]*)?]]></regex>
       <style>identifier</style>
     </rule>
   </rule>
 </language>
 <language name="make" inherit="plain">
   <rule>
     <regex><![CDATA[#.*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[^( *| [ \t]*)[A-Za-z0-9_+]*[ \t]*(\+|:)?=]]></regex>
     <style>makefile assignment</style>
   </rule>
   <rule>
     <regex><![CDATA[^ *([A-Za-z0-9./$(){} _%+-]|\n)*::?]]></regex>
     <style>makefile dependency line</style>
     <rule>
       <regex><![CDATA[[A-Za-z0-9./$(){} _%+-]+]]></regex>
       <style>makefile dependency target</style>
     </rule>
     <rule>
       <regex><![CDATA[\\\n]]></regex>
       <style>makefile dependency continuation</style>
     </rule>
     <rule>
       <regex><![CDATA[#.*?$]]></regex>
       <style>comment</style>
     </rule>
     <rule>
       <regex><![CDATA[\$([A-Za-z0-9_]|\([^)]*\)|{[^}]*})]]></regex>
       <style>makefile macro</style>
     </rule>
     <rule>
       <regex><![CDATA[\$([<@*?%]|\$@)]]></regex>
       <style>makefile int macro</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\\$]]></regex>
     <style>makefile continuation</style>
   </rule>
   <rule>
     <regex><![CDATA[\$([A-Za-z0-9_]|\([^)]*\)|{[^}]*})]]></regex>
     <style>makefile macro</style>
   </rule>
   <rule>
     <regex><![CDATA[\$([<@*?%]|\$@)]]></regex>
     <style>makefile int macro</style>
   </rule>
   <rule>
     <regex><![CDATA[\$\$]]></regex>
     <style>makefile escaped dollar</style>
   </rule>
   <rule>
     <regex><![CDATA[^include[ \t]]]></regex>
     <style>include</style>
   </rule>
 </language>
 <language name="makefile" inherit="make"/>
 <language name="matlab" inherit="plain">
   <rule>
     <regex><![CDATA[%.*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[\b((([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(i|j)?\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(break|case|catch|continue|else|elseif|end|for|function|global|if|otherwise|persistent|return|switch|try|while)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[([+\-\*\\/:()\[\]\.,;!'=&|~])|(\.[\*\^/])|(==)|(<>)|(xor)|(kron)]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[\b[a-zA-Z_][a-zA-Z0-9_]*\b]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="m" inherit="matlab" />
 <language name="pas" inherit="plain">
   <rule>
     <regex><![CDATA[\(\*.*?\*\)]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[\{.*?\}]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA['.*?('|$)]]></regex>
     <style>string</style>
   </rule>
   <rule>
     <regex><![CDATA[^[ \t]*#.*?$]]></regex>
     <style>preprocessor</style>
     <rule>
       <regex><![CDATA[\(\*.*?\*\)]]></regex>
       <style>comment</style>
     </rule>
     <rule>
       <regex><![CDATA[\{.*?\}]]></regex>
       <style>comment</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA['.']]></regex>
     <style>character</style>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|[0-9.]+((e|E)(\+|-)?)?[0-9]*)(L|l|UL|ul|u|U|F|f)?\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(?i)(and|array|const|div|export|file|function|import|in|label|mod|module|nil|not|only|or|packed|pow|pragma|procedure|program|protected|qualified|record|restricted|set|type|var)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(?i)(begin|case|do|downto|else|end|for|goto|if|of|otherwise|repeat|then|to|until|while|with)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[([\*\-\+=:;<>\(\)\[\]!]|[^/]/[^/])]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9.^]*[a-zA-Z_0-9]|[a-zA-Z_][a-zA-Z_0-9]*)]]></regex>
     <style>identifier</style>
     <rule>
       <regex><![CDATA[(\.|\^)+]]></regex>
       <style>symbol</style>
     </rule>
   </rule>
 </language>
 <language name="pascal" inherit="pas"/>
 <language name="perl" inherit="plain">
   <rule>
     <regex><![CDATA[(?:#.*?(?:\r?\n\s*)+)+]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[[\$@%]\$?(?:{[^}]*}|[^a-zA-Z0-9_/\t\n\.,\\[\\{\\(]|[0-9]+|[a-zA-Z_][a-zA-Z0-9_]*)?]]></regex>
     <style>identifier</style>
   </rule>
   <rule>
     <regex><![CDATA[""|".*?([^\\](\\\\)*)"|"\\\\"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
     <rule>
       <regex><![CDATA[[\$@%]\$?(?:{[^}]*}|[^a-zA-Z0-9_/\t\n\.,\\[\\{\\(]|[0-9]+|[a-zA-Z_][a-zA-Z0-9_]*)?]]></regex>
       <style>identifier</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[|'.*?([^\\](\\\\)*)'|'\\\\']]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[sub[\t ]+(?:[a-zA-Z0-9_]+)[\t \n]*(?:\{|\(|\n)]]></regex>
     <style>function header</style>
     <rule>
       <regex><![CDATA[[\t ][a-zA-Z0-9_]+]]></regex>
       <style>function header name</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[(?:\b| )?(?:/(?:\\/|[^/\n])*(?:/[gimesox]*)|s([^\w\s])(?:\\\2|[^\2\n])*?(\2)[^(\2)\n]*?(\2[gimesox]*))]]></regex>
     <style>regex</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(my|local|new|if|until|while|elsif|else|eval|unless|for|foreach|continue|exit|die|last|goto|next|redo|return|local|exec|do|use|require|package|eval|BEGIN|END|eq|ne|not|\|\||\&\&|and|or)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(?:a(?:bs|ccept|larm|tan2)|b(?:ind|inmode|less)|c(?:aller|hdir|hmod|homp|hop|hr|hroot|hown|losedir|lose|onnect|os|rypt)|d(?:bmclose|bmopen|efined|elete|ie|ump)|e(?:ach|nd(?:grent|hostent|netent|protoent|pwent|servent)|of|xec|xists|xp)|f(?:ctnl|ileno|lock|ork|ormat|ormline)|g(?:et(?:c|grent|grgid|grnam|hostbyaddr|hostbyname|hostent|login|netbyaddr|netbyname|netent|peername|pgrp|ppid|priority|protobyname|protobynumber|protoent|pwent|pwnam|pwuid|servbyname|servbyport|servent|sockname|sockopt)|lob|mtime|rep)|hex|i(?:mport|ndex|nt|octl)|join|keys|kill|l(?:cfirst|c|ength|ink|isten|og|ocaltime|stat)|m(?:ap|kdir|sgctl|sgget|sgrcv)|no|o(?:ct|pendir|pen|rd)|p(?:ack|ipe|op|os|rintf|rint|ush)|quotemeta|r(?:and|eaddir|ead|eadlink|ecv|ef|ename|eset|everse|ewinddir|index|mdir)|s(?:calar|eekdir|eek|elect|emctl|emget|emop|end|et(?:grent|hostent|netent|pgrp|priority|protoent|pwent|sockopt)|hift|hmctl|hmget|hmread|hmwrite|hutdown|in|leep|ocket|ocketpair|ort|plice|plit|printf|qrt|rand|tat|tudy|ubstr|ymlink|yscall|ysopen|ysread|ystem|yswrite)|t(?:elldir|ell|ie|ied|ime|imes|runcate)|u(?:c|cfirst|mask|ndef|nlink|npack|nshift|ntie|time)|values|vec|w(?:ait|aitpid|antarray|arn|rite)|qw|-[rwxoRWXOezsfdlpSbctugkTBMAC])\b]]></regex>
     <style>library function</style>
   </rule>
   <rule>
     <regex><![CDATA[[\[\]\{\}\(\)]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[<<(?:("|')([^\n]*)\2|\w*).*?^$]]></regex>
     <style>text</style>
   </rule>
   <rule>
     <regex><![CDATA[^=.*?^(?:=cut|\Z)]]></regex>
     <style>doc comment</style>
   </rule>
 </language>
 <language name="pov" inherit="plain">
   <rule>
     <regex><![CDATA[/\*\*.*?\*/]]></regex>
     <style>doc comment</style>
   </rule>
   <rule>
     <regex><![CDATA[/\*.*?\*/]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[5]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[""|".*?([^\\](\\\\)*)"|"\\\\"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[^[ \t]*#.*?$]]></regex>
     <style>preprocessor</style>
     <rule>
       <regex><![CDATA[""|".*?([^\\](\\\\)*)"|"\\\\"]]></regex>
       <style>string</style>
       <rule>
         <regex><![CDATA[\\.]]></regex>
         <style>esc character</style>
       </rule>
     </rule>
     <rule>
       <regex><![CDATA[<.*?>]]></regex>
       <style>string</style>
     </rule>
     <rule>
       <regex><![CDATA[[^/]/\*.*?\*/]]></regex>
       <style>comment</style>
     </rule>
     <rule>
       <regex><![CDATA[6]]></regex>
       <style>comment</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA['(\\)?.']]></regex>
     <style>character</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character'</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(abs|absorption|acos|acosh|adaptive|adc_bailout|agate|agate_turb|all|alpha|ambient|ambient_light|angle|aperture|append|arc_angle|area_light|array|asc|asin|asinh|assumed_gamma|atan|atan2|atanh|average|background|bezier_spline|bicubic_patch|black_hole|blob|blue|blur_samples|bounded_by|box|boxed|bozo|break|brick|brick_size|brightness|brilliance|bumps|bump_map|bump_size|camera|case|caustics|ceil|checker|chr|clipped_by|clock|clock_delta|color|color_map|colour|colour_map|component|composite|concat|cone|confidence|conic_sweep|control0|control1|cos|cosh|count|crackle|crand|cube|cubic|cubic_spline|cubic_wave|cylinder|cylindrical|debug|declare|default|defined|degrees|density|density_file|density_map|dents|difference|diffuse|dimensions|dimension_size|direction|disc|distance|distance_maximum|div|eccentricity|else|emission|end|error|error_bound|exp|extinction|fade_distance|fade_power|falloff|falloff_angle|false|fclose|file_exists|filter|finish|fisheye|flatness|flip|floor|focal_point|fog|fog_alt|fog_offset|fog_type|fopen|frequency|gif|global_settings|gradient|granite|gray_threshold|green|height_field|hexagon|hf_gray_16|hierarchy|hollow|hypercomplex|if|ifdef|iff|ifndef|image_map|include|int|interior|interpolate|intersection|intervals|inverse|ior|irid|irid_wavelength|jitter|julia_fractal|lambda|lathe|leopard|light_source|linear_spline|linear_sweep|local|location|log|looks_like|look_at|low_error_factor|macro|mandel|map_type|marble|material|material_map|matrix|max|max_intersections|max_iteration|max_trace_level|media|media_attenuation|media_interaction|merge|mesh|metallic|min|minimum_reuse|mod|mortar|nearest_count|no|normal|normal_map|no_shadow|number_of_waves|object|octaves|off|offset|omega|omnimax|on|once|onion|open|orthographic|panoramic|perspective|pgm|phase|phong|phong_size|pi|pigment|pigment_map|planar|plane|png|point_at|poly|polygon|poly_wave|pot|pow|ppm|precision|prism|pwr|quadratic_spline|quadric|quartic|quaternion|quick_color|quick_colour|quilted|radial|radians|radiosity|radius|rainbow|ramp_wave|rand|range|ratio|read|reciprocal|recursion_limit|red|reflection|reflection_exponent|refraction|render|repeat|rgb|rgbf|rgbft|rgbt|right|ripples|rotate|roughness|samples|scale|scallop_wave|scattering|seed|shadowless|sin|sine_wave|sinh|sky|sky_sphere|slice|slope_map|smooth|smooth_triangle|sor|specular|sphere|spherical|spiral1|spiral2|spotlight|spotted|sqr|sqrt|statistics|str|strcmp|strength|strlen|strlwr|strupr|sturm|substr|superellipsoid|switch|sys|t|tan|tanh|text|texture|texture_map|tga|thickness|threshold|tightness|tile2|tiles|torus|track|transform|translate|transmit|triangle|triangle_wave|true|ttf|turbulence|turb_depth|type|u|ultra_wide_angle|undef|union|up|use_color|use_colour|use_index|u_steps|v|val|variance|vaxis_rotate|vcross|vdot|version|vlength|vnormalize|vrotate|v_steps|warning|warp|water_level|waves|while|width|wood|wrinkles|write|x|y|yes|z)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[[\{\}]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[([\*\-\+=:;%&\|<>\(\)\[\]!])]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9]*)]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="povray" inherit="pov"/>
 <language name="python" inherit="plain">
   <rule>
     <regex><![CDATA[#.*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[("""(.|\n)*?""")|((.|\n)*?)]]></regex>
     <style>string</style>
   </rule>
   <rule>
     <regex><![CDATA['([^\\']|(\\.))*']]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA["([^\\"]|(\\.))*"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA['(\\)?.']]></regex>
     <style>character</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(and|assert|break|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|not|or|pass|print|raise|return|try|while)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[[\{\}]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[([\*\-\+=:;%&\|<>\(\)\[\]!])]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9]*)]]></regex>
     <style>identifier</style>
   </rule>
   <rule>
     <regex><![CDATA[[\t ]*def[\t ]+([a-zA-Z0-9_]+)[\t \(]+.*?[\n{]]]></regex>
     <style>function header</style>
     <rule>
       <regex><![CDATA[\(.*?\)]]></regex>
       <style>function header args</style>
     </rule>
     <rule>
       <regex><![CDATA[[\t ][a-zA-Z0-9_]+]]></regex>
       <style>function header name</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b(__import__|abs|apply|buffer|callable|chr|cmp|coerce|compile|complex|delatter|dir|divmod|eval|execfile|filter|float|getattr|globals|hasattr|hash|hex|id|input|int|intern|isinstance|issubclass|len|list|locals|long|map|max|min|oct|open|ord|pow|range|raw_input|reduce|reload|repr|round|setattr|slice|str|tuple|type|unichr|unicode|vars|xrange|zip)\b]]></regex>
     <style>library function</style>
   </rule>
 </language>
 <language name="py" inherit="python"/>
 <language name="ruby" inherit="plain">
   <rule>
     <regex><![CDATA[(?:#.*?(?:\r?\n\s*)+)+]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[(?:\$(?:[!@&`'+\d~=/\\,;.<>_*\$?:"]|DEBUG|FILENAME|LOAD_PATH|stdin|stdout|stderr|VERBOSE|-[0adFiIlpv])|\b(?:TRUE|FALSE|NIL|STDIN|STDOUT|STDERR|ENV|ARGF|ARGV|DATA|RUBY_VERSION|RUBY_RELEASE_DATE|RUBY_PLATFORM)\b)]]></regex>
     <style>predefined identifier</style>
   </rule>
   <rule>
     <regex><![CDATA[[\$@](?:{[^}]*}|[^\w/\t\n\.,\\[\\{\\(]|[0-9]+|[a-zA-Z_][\w.]*)?]]></regex>
     <style>identifier</style>
   </rule>
   <rule>
     <regex><![CDATA[""|"(?:\\\\)+"|".*?(?:[^\\](?:\\\\)*)"|%[Qwx]?([^\w\[\](){}<>])\2|%[Qwx]?([^\w\[\](){}<>]).*?(?:[^\\](?:\\\\)*)\3|%[Qwx]?([^\w\[\](){}<>])\\\\\4|%[Qwx]?\[\]|%[Qwx]?\[.*?([^\\](\\\\)*)\]|%[Qwx]?\[\\\\\]|%[Qwx]?\{\}|%[Qwx]?\{.*?([^\\](\\\\)*)\}|%[Qwx]?\{\\\\\}|%[Qwx]?\(\)|%[Qwx]?\(.*?([^\\](\\\\)*)\)|%[Qwx]?\(\\\\\)|%[Qwx]?<>|%[Qwx]?<.*?([^\\](\\\\)*)>|%[Qwx]?<\\\\>]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\(?:x[\da-fA-F]{2}|\d\d\d|c.|M-\\C-.|M-.|C-.|.)]]></regex>
       <style>esc character</style>
     </rule>
     <rule>
       <regex><![CDATA[#[\$\@][a-zA-Z_][\w.]*|#\{[\$\@]?[^\}]*\}]]></regex>
       <style>identifier</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[|'(?:\\\\)+'|'.*?(?:[^\\](?:\\\\)*)'|%q([^\w\[\](){}<>])\2|%q([^\w\[\](){}<>]).*?(?:[^\\](?:\\\\)*)\3|%q([^\w\[\](){}<>])\\\\\4|%q\[\]|%q\[.*?([^\\](\\\\)*)\]|%q\[\\\\\]|%q\{\}|%q\{.*?([^\\](\\\\)*)\}|%q\{\\\\\}|%q\(\)|%q\(.*?([^\\](\\\\)*)\)|%q\(\\\\\)|%q<>|%q<.*?([^\\](\\\\)*)>|%q<\\\\>]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[(?:\\'|\\\\)]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[def[\t ]+\w[\w.]*(?:\([^)]*\))?]]></regex>
     <style>function header</style>
     <rule>
       <regex><![CDATA[\(.*\)]]></regex>
       <style>function header args</style>
       <rule>
         <regex><![CDATA\(\)]></regex>
         <style>symbol</style>
       </rule>
     </rule>
     <rule>
       <regex><![CDATA[[\t ]\w+]]></regex>
       <style>function header name</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[class[\t ]+\w+(?:\s*<\s*\w+)?]]></regex>
     <style>function header</style>
     <rule>
       <regex><![CDATA[<\s*\w+]]></regex>
       <style>include</style>
       <rule>
         <regex><![CDATA[<]]></regex>
         <style>symbol</style>
       </rule>
     </rule>
     <rule>
       <regex><![CDATA[[\t ]\w+]]></regex>
       <style>type</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[(?:%r([^\w\[\](){}<>])\2|%r([^\w\[\](){}<>]).*?(?:[^\\](?:\\\\)*)\3|%r([^\w\[\](){}<>])\\\\\4|%r\[\]|%r\[.*?([^\\](\\\\)*)\]|%r\[\\\\\]|%r\{\}|%r\{.*?([^\\](\\\\)*)\}|%r\{\\\\\}|%r\(\)|%r\(.*?([^\\](\\\\)*)\)|%r\(\\\\\)|%r<>|%r<.*?([^\\](\\\\)*)>|%r<\\\\>)[ixpno]*]]></regex>
     <style>regex</style>
     <rule>
       <regex><![CDATA[#[\$\@][a-zA-Z_][\w.]*|#\{[\$\@]?[a-zA-Z_][^\}]*\}]]></regex>
       <style>identifier</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[(?:\b| )?(?:/(?:\\/|[^/\n])*(?:/[ixpno]*))]]></regex>
     <style>regex</style>
     <rule>
       <regex><![CDATA[#[\$\@][a-zA-Z_][\w.]*|#\{[\$\@]?[a-zA-Z_][^\}]*\}]]></regex>
       <style>identifier</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b(BEGIN|class|ensure|nil|self|when|END|def|false|not|super|while|alias|defined|for|or|then|yield|and|do|if|redo|true|begin|else|in|rescue|undef|break|elsif|module|retry|unless|case|end|next|return|until)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(Array|Float|Integer|String|at_exit|autoload|binding|caller|catch|chop|chomp|chomp!|eval|exec|exit|fail|fork|format|gets|global_variables|gsub|iterator|lambda|load|local_variables|loop|open|p|print|printf|proc|putc|puts|raise|rand|readline|readlines|require|select|sleep|split|sprintf|srand|sub|syscall|system|test|trace_var|trap|untrace_var)\b]]></regex>
     <style>library function</style>
   </rule>
   <rule>
     <regex><![CDATA[[\[\]\{\}\(\)]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[<<(?:("|')([^\n]*)\2|\w*).*?^$]]></regex>
     <style>text</style>
   </rule>
   <rule>
     <regex><![CDATA[(?:[:*-+<>=^!,/]+|\.\.+)]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[\d[\d.]*]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[^=.*?^(?:=end|\Z)]]></regex>
     <style>doc comment</style>
   </rule>
 </language>
 <language name="rb" inherit="ruby" />
 <language name="sql" inherit="plain">
   <rule>
     <regex><![CDATA[(?i)(,|%|<|>|:=|=|\(|\)|\bselect|on|from|order by|desc|where|and|or|not|null|true|false)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[--.*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[/\*.*?\*/]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[|'.*?([^\\](\\\\)*)'|'\\\\']]></regex>
     <style>string</style>
   </rule>
   <rule>
     <regex><![CDATA[(?i)end if;|\b(create|replace|begin|end|function|return|fetch|open|close|into|is|in|when|others|grant|on|to|exception|show|set|out|pragma|as|package)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[(?i)\balter\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[(?i)\b(integer|blol|date|numeric|character|varying|varchar|char)\b]]></regex>
     <style>predefined type</style>
   </rule>
   <rule>
     <regex><![CDATA[(?i)\b(constraint|key|references|primary|table|foreign|add|insert|group by)\b]]></regex>
     <style>reserved word</style>
   </rule>
 </language>
 <language name="patch" inherit="plain">
   <rule>
     <regex><![CDATA[^Index: .*?$|^===== .*?$|^diff .*?$|^--- .*?$|^\+\+\+ .*?$]]></regex>
     <style>patch separator</style>
   </rule>
   <rule>
     <regex><![CDATA[^@@ .*?$]]></regex>
     <style>patch line spec</style>
   </rule>
   <rule>
     <regex><![CDATA[^-.*?$]]></regex>
     <style>patch deletion</style>
   </rule>
   <rule>
     <regex><![CDATA[^\+.*?$]]></regex>
     <style>patch insertion</style>
   </rule>
 </language>
 <language name="shellscript" inherit="plain">
   <rule>
     <regex><![CDATA[(^| )#([^\!].)*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[[a-zA-Z][a-zA-Z0-9_]*=]]></regex>
     <style></style>
     <rule>
       <regex><![CDATA[[a-zA-Z][a-zA-Z0-9_]*]]></regex>
       <style>identifier</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\$([0-9#\*]|[a-zA-Z][a-zA-Z0-9_]*)]]></regex>
     <style>identifier</style>
   </rule>
   <rule>
     <regex><![CDATA[^[ \t]*#!.*?$]]></regex>
     <style>preprocessor</style>
   </rule>
   <rule>
     <regex><![CDATA[""|"(\\"|[^\"])*"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\$([0-9#\*]|[a-zA-Z][a-zA-Z0-9_]*)]]></regex>
       <style>identifier</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA['.*?']]></regex>
     <style>string</style>
   </rule>
   <rule>
     <regex><![CDATA[case|else|esac|done|do|elif|for|fi|then|until|while|if]]></regex>
     <style>reserved word</style>
   </rule>
 </language>
 <language name="sh" inherit="shellscript"/>
 <language name="scm" inherit="plain">
   <rule>
     <regex><![CDATA[#\|.*?\|#]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(define|lambda|begin|set!)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[[?!]|(\#\')]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA()]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[;.*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[".*?("|$)]]></regex>
     <style>string</style>
   </rule>
   <rule>
     <regex><![CDATA[(#\([0-9]+ [0-9]+\)|[0-9]+)]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[([-a-zA-Z]+)]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="scheme" inherit="scm" />
 <language name="haskell" inherit="plain">
   <rule>
     <regex><![CDATA[{-.*?-}]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[--.*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[""|".*?([^\\](\\\\)*)"|"\\\\"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(0(o|O)[0-7]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(~)?[0-9]+)?)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[(Bool|Bounded|Char|Double|Enum|Eq|FilePath|Float|Floating|Fractional|Functor|Int|Integer|Integral|IO|IOError|Maybe|Monad|Num|Ord|Read|ReadS|Real|RealFloat|RealFrac|Show|ShowS|String)]]></regex>
     <style>predefined types</style>
   </rule>
   <rule>
     <regex><![CDATA[[\[\]\(\)]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[\b((->)|(<-)|(=>)|(\|)|type|data|let|in|case|of|module|class|where|instance|import|do|deriving|if|then|else|newtype|hiding|infix|infixl|infixr|primitive)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[([_:\+\-\*=<>~@\\])|(\.\.)]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(True|False)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9]*'*)]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="hs" inherit="haskell" />
 <language name="occam" inherit="plain">
   <rule>
     <regex><![CDATA[--.*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[^[ \t]*#.*?$]]></regex>
     <style>preprocessor</style>
   </rule>    
   <rule>
     <regex><![CDATA[""|".*?([^\*](\*\*)*)"|"\*\*"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\*.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)?\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[(BOOL|BYTE|CHAN|INT|INT32|INT16|INT64|REAL32|REAL64|)]]></regex>
     <style>predefined types</style>
   </rule>
   <rule>
     <regex><![CDATA[([+\-\*/\\\?!=<>~:;\[\]\(\)])|(>>)|(<<)|(<>)|(><)|(>=)|(<=)|(:=)|(/\\)|(\\/)]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(ALT|ASM|CASE|IF|INLINE|PAR|PLACED|PRI|RESULT|SEQ|VALOF|WHILE|AT|ELSE|FOR|FROM|IS|PLACE|PORT|PROTOCOL|SKIP|STOP|VAL|AFTER|AND|ANY|BITAND|BITNOT|BITOR|BYTESIN|DATA|MINUS|MOSTNEG|MOSTPOS|NOT|PLUS|OF|OFFSETOF|OR|PACKED|RECORD|REM|RESHAPES|RETYPES|ROUND|SIZE|TIMER|TIMES|TRUNC|TYPE|BUCKET|CLAIM|ENROLL|EVENT|FALL|FLUSH|GRANT|INITIAL|RESOURCE|SEMAPHORE|SHARED|SYNC|MOBILE)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(TRUE|FALSE)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[[\t ]*(PROC|FUNCTION)[\t ]+([a-zA-Z][a-zA-Z0-9.]*)[\t ]\(+.*?[\n]]]></regex>
     <style>function header</style>
     <rule>
       <regex><![CDATA[\(.*?\)]]></regex>
       <style>function header args</style>
     </rule>
     <rule>
       <regex><![CDATA[[\t ][a-zA-Z][a-zA-Z0-9.]*]]></regex>
       <style>function header name</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z][a-zA-Z0-9.]*)]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="occ" inherit="occam" />
 <language name="mathematica" inherit="plain">
   <rule>
     <regex><![CDATA[\(\*.*?\*\)]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[\b((([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(i|j)?\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[([+\-\*/\(\)\[\]{},;!=&#])|(==)|(!=)|(>=)|(<=)|(//)|(->)|(:=)|(\*^)|(@@)|(/@)]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[\\\[.*?\]]]></regex>
     <style>mathematica boxed character</style>
   </rule>
   <rule>
     <regex><![CDATA[\b[a-zA-Z_][a-zA-Z0-9_]*_\b]]></regex>
     <style>function header args</style>
   </rule>
   <rule>
     <regex><![CDATA[\b[a-zA-Z_][a-zA-Z0-9_]*\b]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="c#" inherit="plain">
   <rule>
     <regex><![CDATA[/\*.*?\*/]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[7]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[8]]></regex>
     <style>doc comment</style>
   </rule>
   <rule>
     <regex><![CDATA[""|".*?([^\\](\\\\)*)"|"\\\\"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[|'.*?([^\\](\\\\)*)'|'\\\\']]></regex>
     <style>string</style>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(using)\b.*?$]]></regex>
     <style>include</style>
     <rule>
       <regex><![CDATA[[^/]/\*.*?\*/]]></regex>
       <style>comment</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b(abstract|event|new|struct|as|explicit|null|switch|base|extern|object|this|bool|false|operator|throw|break|finally|out|true|byte|fixed|override|try|case|float|params|typeof|catch|for|private|uint|char|foreach|protected|ulong|checked|goto|public|unchecked|class|if|readonly|unsafe|const|implicit|ref|ushort|continue|in|return|using|decimal|int|sbyte|virtual|default|interface|sealed|volatile|delegate|internal|short|void|do|is|sizeof|while|double|lock|stackalloc|else|long|static|enum|namespace|string|where)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[[\{\}\(\)\[\]]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[\b[a-zA-Z_][a-zA-Z0-9_]*\b]]></regex>
     <style>identifier</style>
   </rule>
   <rule>
     <regex><![CDATA[([\*\-\+=:;%&\|<>!])]]></regex>
     <style>symbol</style>
   </rule>
 </language>
 <language name="cs" inherit="c#" />
 <language name="delphi" inherit="plain">
   <rule>
     <regex><![CDATA[\(\*.*?\*\)]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[\{.*?\}]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA['.*?('|$)]]></regex>
     <style>string</style>
   </rule>
   <rule>
     <regex><![CDATA[^[ \t]*#.*?$]]></regex>
     <style>preprocessor</style>
     <rule>
       <regex><![CDATA[\(\*.*?\*\)]]></regex>
       <style>comment</style>
     </rule>
     <rule>
       <regex><![CDATA[\{.*?\}]]></regex>
       <style>comment</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA['.']]></regex>
     <style>character</style>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|[0-9.]+((e|E)(\+|-)?)?[0-9]*)(L|l|UL|ul|u|U|F|f)?\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(?i)(and|array|const|div|export|file|function|import|in|label|mod|module|nil|not|only|or|packed|pow|pragma|procedure|program|protected|qualified|record|restricted|set|type|var)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(?i)(begin|case|do|downto|else|end|for|goto|if|of|otherwise|repeat|then|to|until|while|with)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[([\*\-\+=:;<>\(\)\[\]!]|[^/]/[^/])]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9.^]*[a-zA-Z_0-9]|[a-zA-Z_][a-zA-Z_0-9]*)]]></regex>
     <style>identifier</style>
     <rule>
       <regex><![CDATA[(\.|\^)+]]></regex>
       <style>symbol</style>
     </rule>
   </rule>
 </language>
 <language name="oz" inherit="plain">
   <rule>
     <regex><![CDATA[%.*?$]]></regex>
     <style>comment</style>
   </rule>  
   <rule>
     <regex><![CDATA[/\*.*?\*/]]></regex>
     <style>comment</style>
   </rule>  
   <rule>
     <regex><![CDATA[""|".*?([^\\](\\\\)*)"|"\\\\"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[|'.*?([^\\](\\\\)*)'|'\\\\']]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(b|B)[01]*)|(0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(~)?[0-9]+)?)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[([\(\)\[\]\{\}\|#:,.\^\$_!=\-\*~\+/@<>])|(:=)|(\[\])|(<\-)|(\.\.\.)|(!!)|(<=)|(==)|(\\=)|(=<)|(>=)|(=:)|(\\=:)|(<:)|(=<:)|(>:)|(>=:)|(::)|(:::)]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(andthen|at|attr|case|catch|choice|class|cond|do|declare|define|dis|div|else|elsecase|elseif|end|export|fail|false|feat|finally|for|from|functor|if|import|in|local|lock|meth|mod|not|of|or|orelse|prepare|prop|raise|require|self|skip|then|thread|true|try|unit)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(proc|fun)[\t ]+(\{.*?\})]]></regex>
     <style>function header</style>
     <rule>
       <regex><![CDATA[(\{.*?\})]]></regex>
       <style>function header args</style>
       <rule>
         <regex><![CDATA[^\{[\t ]*(([A-Z][a-zA-Z0-9_]*)|(\$))[\t ]]]></regex>
         <style>function header name</style>
         <rule>
           <regex><![CDATA[(\{)]]></regex>
           <style>function header args</style>
         </rule>
       </rule>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b(true|false)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9]*)]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="sml" inherit="plain">
   <rule>
     <regex><![CDATA[\(\*.*?\*\)]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[""|".*?([^\\](\\\\)*)"|"\\\\"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(~)?[0-9]+)?)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[(unit|int|word|real|char|string|substring|exn|array|vector|ref|bool|option|order|list)]]></regex>
     <style>predefined types</style>
   </rule>
   <rule>
     <regex><![CDATA[(Bind|Chr|Div|Domain|Empty|Fail|Match|Option|Overflow|Size|Span|Subscript)]]></regex>
     <style>predefined types</style>
   </rule>
   <rule>
     <regex><![CDATA[[\[\]\(\)\{\}]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[\b((=>)|(->)|abstype|andalso|case|datatype|div|do|else|end|eqtype|exception|fn|fun|functor|handle|if|in|include|infix|infixr|let|local|mod|nonfix|of|open|orelse|raise|rec|sharing|sig|signature|struct|structure|then|type|val|while|with|withtype)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[([!%&$#+-/:_<=>?@\\~`\^\|\*])]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(true|false)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9]*)]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="aliceml" inherit="sml">
   <rule>
     <regex><![CDATA[\b(any|assert|constructor|exttype|fct|finally|from|import|non|lazy|pack|spawn|unpack|withfun|withval|_file_|_line_)\b]]></regex>
     <style>reserved word</style>
   </rule>
 </language>
 <language name="aml" inherit="aliceml" />
 <language name="ocaml" inherit="plain">
   <rule>
     <regex><![CDATA[\(\*.*?\*\)]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[""|"(\\\\)*"|".*?([^\\](\\\\)*)"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[\\.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(~)?[0-9]+)?)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[(unit|int|float|char|string|exn|format|option|array|vector|bool|list)]]></regex>
     <style>predefined types</style>
   </rule>
   <rule>
     <regex><![CDATA[[\[\]\(\)\{\}]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[\b((=>)|(->)|(\|\|)|(&&)|and|as|assert|begin|class|constraint|div|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|infix|infixr|inherit|initializer|lazy|let|local|match|method|mod|module|mutable|new|nonfix|object|of|open|or|private|rec|sig|signature|struct|then|to|try|type|val|virtual|when|while|with|withtype)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[([!%&$#+-/:_<=>?@\\~`\^\|\*])]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(true|false)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9]*)]]></regex>
     <style>identifier</style>
   </rule>
 </language>
 <language name="xml" inherit="plain">
   <rule>
     <regex><![CDATA[()]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[(<!ENTITY.*?>)]]></regex>
     <style>xml entity</style>
     <rule>
       <regex><![CDATA[()]]></regex>
       <style>comment</style>
     </rule>
     <rule>
       <regex><![CDATA[""|".*?"||'.*?']]></regex>
       <style>string</style>
     </rule>
     <rule>
       <regex><![CDATA[(SYSTEM)]]></regex>
       <style>reserved word</style>
     </rule>
     <rule>
       <regex><![CDATA[([=%])]]></regex>
       <style>symbol</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[(<!\[CDATA\[.*?\]\]>)]]></regex>
     <style>xml entity</style>
     <rule>
       <regex><![CDATA[(\[.*?\])]]></regex>
       <style>identifier</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[(<!.*?>)]]></regex>
     <style>xml entity</style>
     <rule>
       <regex><![CDATA[()]]></regex>
       <style>comment</style>
     </rule>
     <rule>
       <regex><![CDATA[""|".*?"||'.*?']]></regex>
       <style>string</style>
     </rule>
     <rule>
       <regex><![CDATA[(%.*?;)]]></regex>
       <style>function header args</style>
     </rule>
     <rule>
       <regex><![CDATA[(CDATA|EMPTY|INCLUDE|IGNORE|NDATA|#IMPLIED|#PCDATA|#REQUIRED)]]></regex>
       <style>reserved word</style>
     </rule>
     <rule>
       <regex><![CDATA[([\(\)\*\|,\?\+])]]></regex>
       <style>symbol</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[(<\?.*?>)]]></regex>
     <style>xml entity</style>
   </rule>
   <rule>
     <regex><![CDATA[((<.*?>)|(</.*?>))]]></regex>
     <style>xml tag</style>
     <rule>
       <regex><![CDATA[()]]></regex>
       <style>comment</style>
     </rule>
     <rule>
       <regex><![CDATA[""|".*?"||'.*?']]></regex>
       <style>string</style>
     </rule>
     <rule>
       <regex><![CDATA[(:)]]></regex>
       <style>symbol</style>
     </rule>
   </rule>
   <rule>
     <regex><![CDATA[(&.*?;)]]></regex>
     <style>symbol</style>
   </rule>
 </language>
 <language name="eiffel" inherit="plain">
   <rule>
     <regex><![CDATA[--.*?$]]></regex>
     <style>comment</style>
   </rule>
   <rule>
     <regex><![CDATA[""|"(%%)*"|".*?([^%](%%)*)"]]></regex>
     <style>string</style>
     <rule>
       <regex><![CDATA[%.]]></regex>
       <style>esc character</style>
     </rule>
   </rule>    
   <rule>
     <regex><![CDATA[\b(([0-9][0-9a-fA-F]*(x|X))|([01]*[bB])|(([0-9][0-9_]*)|(\.[0-9_]+))((e|E)(\+-)?[0-9_]+)?)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[(CHARACTER|STRING|INTEGER|NUMERIC|REAL|BOOLEAN|ARRAY|LINKED_LIST|HASH_TABLE|RANDOM|DOUBLE)]]></regex>
     <style>predefined types</style>
   </rule>
   <rule>
     <regex><![CDATA[[\[\]\(\)\{\}]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(agent|alias|all|and|as|check|class|create|creation|debug|deferred|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|indexing|infix|inherit|inspect|invariant|is|like|local|loop|not|obsolete|old|once|or|prefix|redefine|rename|require|rescue|retry|select|separate|strip|then|undefine|unique|until|variant|when|xor)\b]]></regex>
     <style>reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[([:=<>\+\-*/])]]></regex>
     <style>symbol</style>
   </rule>
   <rule>
     <regex><![CDATA[\b([Rr]esult|[Cc]urrent|[Ff]alse|[Pp]recursor|[Vv]oid|[Tt]rue)\b]]></regex>
     <style>numeric</style>
   </rule>
   <rule>
     <regex><![CDATA[([a-zA-Z_][a-zA-Z_0-9]*)]]></regex>
     <style>identifier</style>
   </rule>    
 </language>
 <language name="e" inherit="eiffel"/>
 <language name="vbnet" inherit="plain">
   <rule>
     <regex><![CDATA['.*?$]]></regex>
     <style>Visual Studio comment</style>
   </rule>
   <rule>
     <regex><![CDATA["([^"]|"")*"]]></regex>
     <style>Visual Studio string</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(AddHandler|AddressOf|Alias|And|AndAlso|As|Boolean|ByRef|Byte|ByVal|Call|Case|Catch|CBool|CByte|CChar|CDate|CDec|CDbl|Char|CInt|Class|CLng|CObj|Const|Continue|CSByte|CShort|CSng|CStr|CType|CUInt|CULng|CUShort|Date|Decimal|Declare|Default|Delegate|Dim|DirectCast|Do|Double|Each|Else|ElseIf|End|EndIf|Enum|Erase|Error|Event|Exit|False|Finally|For|Friend|Function|Get|GetType|Global|GoSub|GoTo|Handles|If|Implements|Imports|In|Inherits|Integer|Interface|Is|IsNot|Let|Lib|Like|Long|Loop|Me|Mod|Module|MustInherit|MustOverride|MyBase|MyClass|Namespace|Narrowing|New|Next|Not|Nothing|NotInheritable|NotOverridable|Object|Of|On|Operator|Option|Optional|Or|OrElse|Overloads|Overridable|Overrides|ParamArray|Partial|Private|Property|Protected|Public|RaiseEvent|ReadOnly|ReDim|REM|RemoveHandler|Resume|Return|SByte|Select|Set|Shadows|Shared|Short|Single|Static|Step|Stop|String|Structure|Sub|SyncLock|Then|Throw|To|True|Try|TryCast|TypeOf|Variant|Wend|UInteger|ULong|UShort|Using|When|While|Widening|With|WithEvents|WriteOnly|Xor|Const)\b]]></regex>
     <style>Visual Studio reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[[\{\}\(\)]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[^#.*?$]]></regex>
     <style>preprocessor</style>
     <rule>
       <regex><![CDATA["([^"]|"")*"]]></regex>
       <style>Visual Studio string</style>
     </rule>
     <rule>
       <regex><![CDATA['.*?$]]></regex>
       <style>Visual Studio comment</style>
     </rule>
     <rule>
       <regex><![CDATA[[\{\}\(\)]]]></regex>
       <style>braces</style>
     </rule>
   </rule>
 </language>
 <language name="vb" inherit="vbnet"/>
 <language name="qbasic" inherit="plain">
   <rule>
     <regex><![CDATA['.*?$]]></regex>
     <style>Visual Studio comment</style>
   </rule>
   <rule>
     <regex><![CDATA["([^"]|"")*"]]></regex>
     <style>Visual Studio string</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(ABSOLUTE|ACCESS|AND|ANY|APPEND|AS|BASE|BEEP|BINARY|BLOAD|BSAVE|BYREF|BYVAL|CALL|CASE|CHAIN|CHDIR|CIRCLE|CLEAR|CLOSE|CLS|COLOR|COM|COMMON|CONST|CSRLIN|DATA|DATE$|DECLARE|DEF|DEFDBL|DEFINT|DEFLNG|DEFSNG|DEFSTR|DIM|DO|DOUBLE|DRAW|$DYNAMIC|ELSE|ELSEIF|END|ENVIRON|EQV|ERASE|ERROR|EXIT|FIELD|FILES|FOR|FREEFILE|FUNCTION|GET|GOSUB|GOTO|IF|IMP|INKEY$|INPUT|INTEGER|IOCTL|IS|KEY|KILL|LET|LINE|LIST|LOCATE|LOCK|LONG|LOOP|LPRINT|LSET|MKDIR|MOD|NAME|NEXT|NOT|OFF|ON|OPEN|OPTION|OR|OUT|OUTPUT|PAINT|PALETTE|PCOPY|PEN|PLAY|POKE|PRESET|PRINT|PSET|PUT|RANDOM|RANDOMIZE|READ|REDIM|REM|RESET|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SCREEN|SEEK|SELECT|SHARED|SHELL|SINGLE|SLEEP|SOUND|STATIC|$STATIC|STEP|STOP|STRIG|STRING|SUB|SWAP|SYSTEM|THEN|TIME$|TIMER|TO|TROFF|TRON|TYPE|UNLOCK|UNTIL|USING|VIEW|WAIT|WEND|WHILE|WIDTH|WINDOW|WRITE|XOR)\b]]></regex>
     <style>Visual Studio reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[\b(ABS|ASC|ATN|CDBL|CHR$|CINT|CLNG|COS|CSNG|CVD|CVDMBF|CVI|CVL|CVS|CVSMBF|ENVIRON$|EOF|ERDEV|ERDEV$|ERL|ERR|EXP|FILEATTR|FIX|FRE|HEX$|INP|INPUT$|INSTR|INT|IOCTL$|KEY|LBOUND|LCASE$|LEFT$|LEN|LOC|LOF|LOG|LPOS|LTRIM$|MID$|MKD$|MKDMBF$|MKI$|MKL$|MKS$|MKSMBF$|OCT$|PEEK|PEN|PMAP|POINT|POS|RIGHT$|RND|RTRIM$|SCREEN|SEEK|SGN|SIN|SPACE$|SPC|SQR|STICK|STR$|STRIG|TAB|TAN|TIMER|UBOUND|UCASE$|VAL|VARPTR|VARPTR$|VARSEG)\(]]></regex>
     <style>Visual Studio reserved word</style>
   </rule>
   <rule>
     <regex><![CDATA[[\{\}\(\)]]]></regex>
     <style>braces</style>
   </rule>
   <rule>
     <regex><![CDATA[^#.*?$]]></regex>
     <style>preprocessor</style>
     <rule>
       <regex><![CDATA["([^"]|"")*"]]></regex>
       <style>Visual Studio string</style>
     </rule>
     <rule>
       <regex><![CDATA['.*?$]]></regex>
       <style>Visual Studio comment</style>
     </rule>
     <rule>
       <regex><![CDATA[[\{\}\(\)]]]></regex>
       <style>braces</style>
     </rule>
   </rule>
 </language>
 <language name="scala" inherit="plain">
  <rule>
    <regex><![CDATA[/\*\*.*?\*/]]></regex>
    <style>doc comment</style>
    <rule>
	  <regex><![CDATA[\s@(param|return|exception|throws|author|version|see|since|serial|deprecated)\b]]></regex>
      <style>javadoc tags</style>
    </rule>
  </rule>
  <rule>
    <regex><![CDATA[/\*.*?\*/]]></regex>
    <style>comment</style>
  </rule>
  <rule>
    <regex><![CDATA[9]]></regex>
    <style>comment</style>
  </rule> 
  <rule>
    <regex><![CDATA[""|"\\\\"|".*?([^\\](\\\\)*)"]]></regex>
    <style>string</style>
    <rule>
      <regex><![CDATA[\\.]]></regex>
      <style>esc character</style>
    </rule>
  </rule>
  <rule>
    <regex><![CDATA[\b(import)\b.*?$]]></regex>
    <style>include</style>
  </rule>
  <rule>
    <regex><![CDATA['(\\)?.']]></regex>
    <style>character</style>
  </rule>
  <rule>
    <regex><![CDATA[(?<=\W)(_)(?=\W)]]></regex>
    <style>reserved word</style>
  </rule>
  <rule>
    <regex><![CDATA[(?<=[ \w\}\]\)])(:|=|(=>)|(<-)|#|@)(?=[ \w\{\[\(])]]></regex>
    <style>reserved word</style>
  </rule>
  <rule>
    <regex><![CDATA[\b(package|abstract|case|catch|class|def|do|else|extends|false|final|finally|for|if|implicit|match|new|null|object|override|private|protected|requires|return|sealed|super|this|throw|trait|try|true|type|val|var|while|with|yield)\b]]></regex>
    <style>reserved word</style>
  </rule>
  <rule>
    <regex><![CDATA[[\[\]]]]></regex>
    <style>type braces and operators</style>
  </rule>
  <rule>
    <regex><![CDATA[(?<=[\s\w\]])(<:|<%|>:)(?=[\s\w])]]></regex>
    <style>type braces and operators</style>
  </rule>
  <rule>
    <regex><![CDATA[[\{\}\(\)]]]></regex>
    <style>braces</style>
  </rule>
  <rule>
    <regex><![CDATA[\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)(L|l|F|f|D|d)?\b]]></regex>
    <style>numeric</style>
  </rule> 
  <rule>
    <regex><![CDATA[\b[a-zA-Z][a-zA-Z0-9_]*\b]]></regex>
    <style>identifier</style>
  </rule>
  <rule>
    <regex><![CDATA[|<\?.*?\?>]]></regex>
    <style>xml tag</style>
  </rule>
  <rule>
    <regex><![CDATA[(<\w.*?>|</.*?>|<\w.*?/>)(\s*(<\w.*?>|</.*?>|<\w.*?/>|((?!(;|=>|if))[^<])*))*]]></regex>
    <style>xml tag</style>
    <rule>
      	
      <regex><![CDATA[{.*?}(?!})]]></regex>
      <style>scala xml scalaExpr</style>
    </rule>
    <rule>
      <regex><![CDATA[""|"(\\"|.)*?"||'(\\'|.)*?']]></regex>
      <style>string</style>
    </rule>
  </rule>   
</language>

<language name="mercury" inherit="plain">

  <rule>
    <regex><![CDATA[/\*\*.*?\*/]]></regex>
    <style>doc comment</style>
    <rule>
	  <regex><![CDATA[\s@(param|return|exception|throws|author|version|see|since|serial|deprecated)\b]]></regex>
      <style>javadoc tags</style>
    </rule>
  </rule>
  <rule>
    <regex><![CDATA[/\*.*?\*/]]></regex>
    <style>comment</style>
  </rule>
  <rule>
    <regex><![CDATA[%.*?\n]]></regex>
    <style>comment</style>
  </rule> 
  <rule>
    <regex><![CDATA["(""|\\\\|\\x[0-9a-fA-F]+|\\[0-7]+|\\.|[^"\\])*"]]></regex>
    <style>string</style>
    <rule>
      <regex><![CDATA[\\x[0-9a-fA-F]+]]></regex>
      <style>esc character</style>
    </rule>
    <rule>
      <regex><![CDATA[\\[0-7]+]]></regex>
      <style>esc character</style>
    </rule>
    <rule>
      <regex><![CDATA[\\.]]></regex>
      <style>esc character</style>
    </rule>
  </rule>
  <rule>
    <regex><![CDATA['(|\\\\|\\x[0-9a-fA-F]+|\\[0-7]+|\\.|[^'\\])*']]></regex>
    <style>identifier</style>
    <rule>
      <regex><![CDATA[\\x[0-9a-fA-F]+]]></regex>
      <style>esc character</style>
    </rule>
    <rule>
      <regex><![CDATA[\\[0-7]+]]></regex>
      <style>esc character</style>
    </rule>
    <rule>
      <regex><![CDATA[\\.]]></regex>
      <style>esc character</style>
    </rule>
  </rule>
  <rule>
    <regex><![CDATA[^:-( |\t)+(import_module|include_module|use_module)\b.*?$]]></regex>
    <style>include</style>
   </rule>
  <rule>
      <regex><![CDATA[^:-( |\t)+(solver type|type|pred|func|inst|mode|typeclass|instance|pragma|promise|module|interface|implementation|end_module)\b]]></regex>
    <style>reserved word</style>
  </rule>
  <rule>
    <regex><![CDATA[\b(in|out|di|uo|is *(det|semidet|multi|nondet))\b]]></regex>
    <style>reserved word</style>
  </rule>
  <rule>
    <regex><![CDATA[\b(some|all|if|then|else)\b]]></regex>
    <style>reserved word</style>
  </rule>
  <rule>
    <regex><![CDATA[[\{\}\(\)\[\]]]]></regex>
    <style>braces</style>
  </rule>
  <rule>
    <regex><![CDATA\,\.;!]></regex>
    <style>reserved word</style>
  </rule>
  <rule>
  	

<regex><![CDATA[\#[0-9]+]]></regex> <style>directive</style>

  </rule>
  <rule>
    <regex><![CDATA[\b(0x[0-9a-fA-F]*)\b]]></regex>
    <style>numeric</style>
  </rule> 
  <rule>
    <regex><![CDATA[\b(0o[0-7]*)\b]]></regex>
    <style>numeric</style>
  </rule> 
  <rule>
    <regex><![CDATA[\b(0b[0-1]*)\b]]></regex>
    <style>numeric</style>
  </rule> 
  <rule>
    <regex><![CDATA[\b(0\'.)\b]]></regex>
    <style>character</style>
  </rule> 
  <rule>
    <regex><![CDATA[\b(([0-9]+)(\.[0-9]+)?(E(\+|-)?[0-9]+)?)\b]]></regex>
    <style>numeric</style>
  </rule>    
  <rule>
  	 
    <regex><![CDATA[\b[a-z][a-zA-Z0-9_]*\b]]></regex>
    <style>identifier</style>
  </rule>
  <rule>
  	 
    <regex><![CDATA[`[a-z][a-zA-Z0-9_]*`]]></regex>
    <style>identifier</style>
  </rule>
  <rule>
  	 
    <regex><![CDATA[\b[_A-Z][a-zA-Z0-9_]*\b]]></regex>
    <style>identifier</style>
  </rule>
</language>

</syntaxhighlightingregexps>

hijacker
hijacker
hijacker
hijacker